feat(asset): 清理被截断的结尾图片引用,修复整单 502
仓库首次入库(此前仅存在于本地工作区与测试服构建产物中,未上传)。 改动(src/knowledge_adapter/asset_content_processor.py): - 新增 _TRUNCATED_TRAILING_MARKDOWN_RESOURCE_IMAGE 规则,清除 chunk 末尾被截断的  - 回归测试 tests/test_asset_content_processor.py:: test_truncated_trailing_markdown_resource_image_is_removed 验证证据: - 测试服 120.76.217.51,镜像 knowledge-adapter-service:reviewed-test-aeab4b5fca2d (release aeab4b5fca2d8661):KB d015d05c-25c8-4d63-b2ab-e8590d3c2dfb 5 个查询全部 http=200、records=5、残留 resource:// = 0;KB b9dacd62 无退化;容器日志无 error/exception - 本地:pytest 141 项全通过、ruff 全通过 - 该文件与 258c31e0fe07fd08 源码的差异经逐文件 md5 比对,为唯一变更文件
This commit is contained in:
@@ -0,0 +1,314 @@
|
||||
import json
|
||||
from datetime import UTC, datetime
|
||||
from uuid import UUID
|
||||
|
||||
import pytest
|
||||
|
||||
from knowledge_adapter.asset_content_processor import (
|
||||
AssetContentProcessor,
|
||||
ContentProcessingError,
|
||||
)
|
||||
from knowledge_adapter.asset_repository import AssetMapping
|
||||
from knowledge_adapter.models import WeKnoraChunk
|
||||
from knowledge_adapter.weknora_resource_resolver import (
|
||||
ResolvedAsset,
|
||||
ResourceResolutionError,
|
||||
)
|
||||
|
||||
SOURCE_REF = "resource://AbCdEfGhIjKlMnOpQrSt_1"
|
||||
ASSET_ID = UUID("c7f61f89-19ce-45b1-ac60-dbeed5e2a491")
|
||||
KB_ID = UUID("3904b40e-278b-4273-a6fa-db6cbc975587")
|
||||
|
||||
|
||||
class RecordingAssetRepository:
|
||||
def __init__(
|
||||
self,
|
||||
mapping: AssetMapping | None,
|
||||
*,
|
||||
created_mapping: AssetMapping | None = None,
|
||||
) -> None:
|
||||
self.mapping = mapping
|
||||
self.created_mapping = created_mapping
|
||||
self.lookup_calls: list[str] = []
|
||||
self.create_calls: list[tuple[str, str, str | None]] = []
|
||||
|
||||
async def get_active_by_source_ref(self, source_ref: str) -> AssetMapping | None:
|
||||
self.lookup_calls.append(source_ref)
|
||||
return self.mapping
|
||||
|
||||
async def get_or_create(
|
||||
self,
|
||||
*,
|
||||
source_ref: str,
|
||||
object_key: str,
|
||||
content_type: str | None,
|
||||
) -> AssetMapping:
|
||||
self.create_calls.append((source_ref, object_key, content_type))
|
||||
if self.created_mapping is None:
|
||||
raise AssertionError("unexpected mapping creation")
|
||||
return self.created_mapping
|
||||
|
||||
|
||||
class RecordingResolver:
|
||||
def __init__(
|
||||
self,
|
||||
resolved: ResolvedAsset | None = None,
|
||||
*,
|
||||
error: Exception | None = None,
|
||||
) -> None:
|
||||
self.resolved = resolved
|
||||
self.error = error
|
||||
self.calls: list[str] = []
|
||||
|
||||
async def resolve(self, source_ref: str) -> ResolvedAsset:
|
||||
self.calls.append(source_ref)
|
||||
if self.error is not None:
|
||||
raise self.error
|
||||
if self.resolved is None:
|
||||
raise AssertionError("unexpected WeKnora DB resolution")
|
||||
return self.resolved
|
||||
|
||||
|
||||
def make_chunk(*, content: str, image_info: str = "") -> WeKnoraChunk:
|
||||
return WeKnoraChunk.model_validate(
|
||||
{
|
||||
"id": "09ab721f-7d05-45de-ae0f-dac303276f6d",
|
||||
"content": content,
|
||||
"score": 0.9,
|
||||
"knowledge_base_id": str(KB_ID),
|
||||
"knowledge_id": "6f77a258-27ff-4278-a667-8fe242ff8e10",
|
||||
"knowledge_title": "Manual",
|
||||
"knowledge_filename": "manual.pdf",
|
||||
"chunk_index": 0,
|
||||
"chunk_type": "text",
|
||||
"image_info": image_info,
|
||||
}
|
||||
)
|
||||
|
||||
|
||||
def active_mapping() -> AssetMapping:
|
||||
return AssetMapping(
|
||||
asset_id=ASSET_ID,
|
||||
source_ref=SOURCE_REF,
|
||||
object_key="weknora/10008/assets/image.png",
|
||||
content_type="image/png",
|
||||
created_at=datetime(2026, 8, 24, tzinfo=UTC),
|
||||
status="active",
|
||||
)
|
||||
|
||||
|
||||
async def test_markdown_resource_uses_existing_mapping_without_weknora_db() -> None:
|
||||
repository = RecordingAssetRepository(active_mapping())
|
||||
resolver = RecordingResolver()
|
||||
processor = AssetContentProcessor(
|
||||
repository=repository,
|
||||
resolver=resolver,
|
||||
public_base_url="https://assets.example.com",
|
||||
)
|
||||
chunk = make_chunk(content=f"Before  after")
|
||||
|
||||
processed = await processor.process(chunk)
|
||||
|
||||
assert processed == (
|
||||
f"Before  after"
|
||||
)
|
||||
assert repository.lookup_calls == [SOURCE_REF]
|
||||
assert repository.create_calls == []
|
||||
assert resolver.calls == []
|
||||
|
||||
|
||||
async def test_html_img_resource_uses_existing_mapping_without_weknora_db() -> None:
|
||||
repository = RecordingAssetRepository(active_mapping())
|
||||
resolver = RecordingResolver()
|
||||
processor = AssetContentProcessor(
|
||||
repository=repository,
|
||||
resolver=resolver,
|
||||
public_base_url="https://assets.example.com",
|
||||
)
|
||||
chunk = make_chunk(content=f'<td><img src="{SOURCE_REF}"/></td>')
|
||||
|
||||
processed = await processor.process(chunk)
|
||||
|
||||
assert processed == (f'<td><img src="https://assets.example.com/i/{ASSET_ID}"/></td>')
|
||||
assert repository.lookup_calls == [SOURCE_REF]
|
||||
assert repository.create_calls == []
|
||||
assert resolver.calls == []
|
||||
|
||||
|
||||
async def test_html_img_resource_preserves_attributes_and_quote_style() -> None:
|
||||
repository = RecordingAssetRepository(active_mapping())
|
||||
resolver = RecordingResolver()
|
||||
processor = AssetContentProcessor(
|
||||
repository=repository,
|
||||
resolver=resolver,
|
||||
public_base_url="https://assets.example.com",
|
||||
)
|
||||
chunk = make_chunk(content=f"<img alt='diagram' src='{SOURCE_REF}' width='100'>")
|
||||
|
||||
processed = await processor.process(chunk)
|
||||
|
||||
assert processed == (
|
||||
f"<img alt='diagram' src='https://assets.example.com/i/{ASSET_ID}' width='100'>"
|
||||
)
|
||||
assert repository.lookup_calls == [SOURCE_REF]
|
||||
assert repository.create_calls == []
|
||||
assert resolver.calls == []
|
||||
|
||||
|
||||
async def test_unmapped_resource_is_resolved_and_persisted_once() -> None:
|
||||
repository = RecordingAssetRepository(
|
||||
None,
|
||||
created_mapping=active_mapping(),
|
||||
)
|
||||
resolver = RecordingResolver(
|
||||
ResolvedAsset(
|
||||
object_key="weknora/10008/assets/image.png",
|
||||
content_type="image/png",
|
||||
)
|
||||
)
|
||||
processor = AssetContentProcessor(
|
||||
repository=repository,
|
||||
resolver=resolver,
|
||||
public_base_url="https://assets.example.com",
|
||||
)
|
||||
|
||||
processed = await processor.process(
|
||||
make_chunk(content=f"")
|
||||
)
|
||||
|
||||
assert processed == f""
|
||||
assert repository.lookup_calls == [SOURCE_REF]
|
||||
assert resolver.calls == [SOURCE_REF]
|
||||
assert repository.create_calls == [
|
||||
(SOURCE_REF, "weknora/10008/assets/image.png", "image/png")
|
||||
]
|
||||
|
||||
|
||||
async def test_duplicate_markdown_resource_is_deduplicated() -> None:
|
||||
repository = RecordingAssetRepository(active_mapping())
|
||||
resolver = RecordingResolver()
|
||||
processor = AssetContentProcessor(
|
||||
repository=repository,
|
||||
resolver=resolver,
|
||||
public_base_url="https://assets.example.com",
|
||||
)
|
||||
chunk = make_chunk(
|
||||
content=f" and "
|
||||
)
|
||||
|
||||
processed = await processor.process(chunk)
|
||||
|
||||
public_url = f"https://assets.example.com/i/{ASSET_ID}"
|
||||
assert processed == f" and "
|
||||
assert repository.lookup_calls == [SOURCE_REF]
|
||||
assert resolver.calls == []
|
||||
|
||||
|
||||
async def test_image_info_only_resource_is_appended_as_stable_image() -> None:
|
||||
repository = RecordingAssetRepository(active_mapping())
|
||||
resolver = RecordingResolver()
|
||||
processor = AssetContentProcessor(
|
||||
repository=repository,
|
||||
resolver=resolver,
|
||||
public_base_url="https://assets.example.com",
|
||||
)
|
||||
image_info = json.dumps(
|
||||
[{"url": SOURCE_REF, "original_url": SOURCE_REF}],
|
||||
ensure_ascii=False,
|
||||
)
|
||||
|
||||
processed = await processor.process(
|
||||
make_chunk(content="Text only", image_info=image_info)
|
||||
)
|
||||
|
||||
public_url = f"https://assets.example.com/i/{ASSET_ID}"
|
||||
assert processed == f"Text only\n\n"
|
||||
assert repository.lookup_calls == [SOURCE_REF]
|
||||
assert resolver.calls == []
|
||||
|
||||
|
||||
async def test_malformed_image_info_fails_with_safe_error() -> None:
|
||||
processor = AssetContentProcessor(
|
||||
repository=RecordingAssetRepository(active_mapping()),
|
||||
resolver=RecordingResolver(),
|
||||
public_base_url="https://assets.example.com",
|
||||
)
|
||||
|
||||
with pytest.raises(ContentProcessingError) as captured:
|
||||
await processor.process(make_chunk(content="Text", image_info="not-json"))
|
||||
|
||||
assert str(captured.value) == "content processing failed"
|
||||
assert "not-json" not in str(captured.value)
|
||||
|
||||
|
||||
async def test_non_array_image_info_fails_closed() -> None:
|
||||
processor = AssetContentProcessor(
|
||||
repository=RecordingAssetRepository(active_mapping()),
|
||||
resolver=RecordingResolver(),
|
||||
public_base_url="https://assets.example.com",
|
||||
)
|
||||
|
||||
with pytest.raises(ContentProcessingError, match=r"^content processing failed$"):
|
||||
await processor.process(make_chunk(content="Text", image_info="{}"))
|
||||
|
||||
|
||||
async def test_resource_resolution_error_is_mapped_to_content_error() -> None:
|
||||
processor = AssetContentProcessor(
|
||||
repository=RecordingAssetRepository(None),
|
||||
resolver=RecordingResolver(error=ResourceResolutionError("resource unavailable")),
|
||||
public_base_url="https://assets.example.com",
|
||||
)
|
||||
|
||||
with pytest.raises(ContentProcessingError, match=r"^content processing failed$"):
|
||||
await processor.process(make_chunk(content=f""))
|
||||
|
||||
|
||||
async def test_unrewritten_resource_reference_never_reaches_dify_content() -> None:
|
||||
processor = AssetContentProcessor(
|
||||
repository=RecordingAssetRepository(active_mapping()),
|
||||
resolver=RecordingResolver(),
|
||||
public_base_url="https://assets.example.com",
|
||||
)
|
||||
|
||||
with pytest.raises(ContentProcessingError, match=r"^content processing failed$"):
|
||||
await processor.process(make_chunk(content=f"internal ref: {SOURCE_REF}"))
|
||||
|
||||
|
||||
async def test_truncated_trailing_markdown_resource_image_is_removed() -> None:
|
||||
processor = AssetContentProcessor(
|
||||
repository=RecordingAssetRepository(active_mapping()),
|
||||
resolver=RecordingResolver(),
|
||||
public_base_url="https://assets.example.com",
|
||||
)
|
||||
|
||||
processed = await processor.process(
|
||||
make_chunk(content="LED indicator meanings\n\n
|
||||
)
|
||||
|
||||
assert processed == "LED indicator meanings\n\n"
|
||||
|
||||
|
||||
@pytest.mark.parametrize(
|
||||
"forbidden_content",
|
||||
[
|
||||
"local://srv/private/image.png",
|
||||
"/home/app/private/image.png",
|
||||
"http://127.0.0.1/image.png",
|
||||
"http://10.0.0.8/image.png",
|
||||
"http://192.168.1.8/image.png",
|
||||
"http://172.16.0.8/image.png",
|
||||
"https://private-assets.oss-cn-shenzhen-internal.aliyuncs.com/image.png",
|
||||
"https://private-assets.oss-cn-shenzhen.aliyuncs.com/image.png",
|
||||
],
|
||||
)
|
||||
async def test_internal_locator_never_reaches_dify_content(
|
||||
forbidden_content: str,
|
||||
) -> None:
|
||||
processor = AssetContentProcessor(
|
||||
repository=RecordingAssetRepository(active_mapping()),
|
||||
resolver=RecordingResolver(),
|
||||
public_base_url="https://assets.example.com",
|
||||
)
|
||||
|
||||
with pytest.raises(ContentProcessingError, match=r"^content processing failed$"):
|
||||
await processor.process(make_chunk(content=forbidden_content))
|
||||
@@ -0,0 +1,126 @@
|
||||
from datetime import UTC, datetime
|
||||
from uuid import UUID
|
||||
|
||||
import pytest
|
||||
|
||||
from knowledge_adapter.asset_redirect import (
|
||||
AssetNotFoundError,
|
||||
AssetRedirectService,
|
||||
AssetRedirectUnavailableError,
|
||||
AssetSignerError,
|
||||
)
|
||||
from knowledge_adapter.asset_repository import (
|
||||
AssetMapping,
|
||||
AssetRepositoryError,
|
||||
)
|
||||
|
||||
ASSET_ID = UUID("c7f61f89-19ce-45b1-ac60-dbeed5e2a491")
|
||||
MAPPING = AssetMapping(
|
||||
asset_id=ASSET_ID,
|
||||
source_ref="resource://AbCdEfGhIjKlMnOpQrSt_1",
|
||||
object_key="weknora/10008/assets/image.png",
|
||||
content_type="image/png",
|
||||
created_at=datetime(2026, 8, 24, tzinfo=UTC),
|
||||
status="active",
|
||||
)
|
||||
SIGNED_URL = (
|
||||
"https://private-assets.oss-cn-shenzhen.aliyuncs.com/"
|
||||
"weknora/10008/assets/image.png?x-oss-signature=redacted"
|
||||
)
|
||||
|
||||
|
||||
class RecordingRepository:
|
||||
def __init__(
|
||||
self,
|
||||
mapping: AssetMapping | None,
|
||||
*,
|
||||
error: Exception | None = None,
|
||||
) -> None:
|
||||
self.mapping = mapping
|
||||
self.error = error
|
||||
self.calls: list[UUID] = []
|
||||
|
||||
async def get_active_by_asset_id(self, asset_id: UUID) -> AssetMapping | None:
|
||||
self.calls.append(asset_id)
|
||||
if self.error is not None:
|
||||
raise self.error
|
||||
return self.mapping
|
||||
|
||||
|
||||
class RecordingSigner:
|
||||
def __init__(
|
||||
self,
|
||||
url: str = SIGNED_URL,
|
||||
*,
|
||||
error: Exception | None = None,
|
||||
) -> None:
|
||||
self.url = url
|
||||
self.error = error
|
||||
self.calls: list[tuple[str, int]] = []
|
||||
|
||||
async def sign_get(self, *, object_key: str, expires_seconds: int) -> str:
|
||||
self.calls.append((object_key, expires_seconds))
|
||||
if self.error is not None:
|
||||
raise self.error
|
||||
return self.url
|
||||
|
||||
|
||||
async def test_redirect_service_signs_only_active_mapped_object() -> None:
|
||||
repository = RecordingRepository(MAPPING)
|
||||
signer = RecordingSigner()
|
||||
service = AssetRedirectService(repository=repository, signer=signer)
|
||||
|
||||
redirect_url = await service.get_redirect_url(ASSET_ID)
|
||||
|
||||
assert redirect_url == SIGNED_URL
|
||||
assert repository.calls == [ASSET_ID]
|
||||
assert signer.calls == [("weknora/10008/assets/image.png", 600)]
|
||||
|
||||
|
||||
async def test_redirect_service_rejects_unknown_asset_without_signing() -> None:
|
||||
repository = RecordingRepository(None)
|
||||
signer = RecordingSigner()
|
||||
service = AssetRedirectService(repository=repository, signer=signer)
|
||||
|
||||
with pytest.raises(AssetNotFoundError, match=r"^asset not found$"):
|
||||
await service.get_redirect_url(ASSET_ID)
|
||||
|
||||
assert repository.calls == [ASSET_ID]
|
||||
assert signer.calls == []
|
||||
|
||||
|
||||
async def test_redirect_service_maps_signer_failure_to_safe_unavailable() -> None:
|
||||
repository = RecordingRepository(MAPPING)
|
||||
signer = RecordingSigner(
|
||||
error=AssetSignerError(
|
||||
"metadata http://100.100.100.200 object_key=private/image.png"
|
||||
)
|
||||
)
|
||||
service = AssetRedirectService(repository=repository, signer=signer)
|
||||
|
||||
with pytest.raises(
|
||||
AssetRedirectUnavailableError,
|
||||
match=r"^asset unavailable$",
|
||||
) as captured:
|
||||
await service.get_redirect_url(ASSET_ID)
|
||||
|
||||
assert "100.100.100.200" not in str(captured.value)
|
||||
assert "object_key" not in str(captured.value)
|
||||
|
||||
|
||||
async def test_redirect_service_maps_repository_failure_without_signing() -> None:
|
||||
repository = RecordingRepository(
|
||||
None,
|
||||
error=AssetRepositoryError("postgresql://adapter@db.internal"),
|
||||
)
|
||||
signer = RecordingSigner()
|
||||
service = AssetRedirectService(repository=repository, signer=signer)
|
||||
|
||||
with pytest.raises(
|
||||
AssetRedirectUnavailableError,
|
||||
match=r"^asset unavailable$",
|
||||
) as captured:
|
||||
await service.get_redirect_url(ASSET_ID)
|
||||
|
||||
assert "postgresql" not in str(captured.value)
|
||||
assert signer.calls == []
|
||||
@@ -0,0 +1,209 @@
|
||||
from contextlib import AbstractAsyncContextManager
|
||||
from datetime import UTC, datetime
|
||||
from types import TracebackType
|
||||
from uuid import UUID
|
||||
|
||||
import pytest
|
||||
|
||||
from knowledge_adapter.asset_repository import (
|
||||
AssetMapping,
|
||||
AssetMappingConflictError,
|
||||
AssetRepository,
|
||||
AssetRepositoryError,
|
||||
)
|
||||
|
||||
SOURCE_REF = "resource://AbCdEfGhIjKlMnOpQrSt_1"
|
||||
ASSET_ID = UUID("c7f61f89-19ce-45b1-ac60-dbeed5e2a491")
|
||||
CREATED_AT = datetime(2026, 8, 24, tzinfo=UTC)
|
||||
|
||||
|
||||
class FakeAssetConnection:
|
||||
def __init__(self, row: dict[str, object] | None) -> None:
|
||||
self.row = row
|
||||
self.query = ""
|
||||
self.args: tuple[object, ...] = ()
|
||||
|
||||
async def fetchrow(self, query: str, *args: object) -> dict[str, object] | None:
|
||||
self.query = query
|
||||
self.args = args
|
||||
return self.row
|
||||
|
||||
|
||||
class FailingAssetConnection(FakeAssetConnection):
|
||||
async def fetchrow(self, query: str, *args: object) -> dict[str, object] | None:
|
||||
raise RuntimeError("postgresql://adapter:secret@db object_key=private/image.png")
|
||||
|
||||
|
||||
class AcquireAssetConnection(AbstractAsyncContextManager[FakeAssetConnection]):
|
||||
def __init__(self, connection: FakeAssetConnection) -> None:
|
||||
self.connection = connection
|
||||
|
||||
async def __aenter__(self) -> FakeAssetConnection:
|
||||
return self.connection
|
||||
|
||||
async def __aexit__(
|
||||
self,
|
||||
exc_type: type[BaseException] | None,
|
||||
exc_value: BaseException | None,
|
||||
traceback: TracebackType | None,
|
||||
) -> None:
|
||||
return None
|
||||
|
||||
|
||||
class FakeAssetPool:
|
||||
def __init__(self, connection: FakeAssetConnection) -> None:
|
||||
self.connection = connection
|
||||
|
||||
def acquire(self) -> AcquireAssetConnection:
|
||||
return AcquireAssetConnection(self.connection)
|
||||
|
||||
|
||||
async def test_get_or_create_uses_atomic_source_ref_upsert() -> None:
|
||||
connection = FakeAssetConnection(
|
||||
{
|
||||
"asset_id": ASSET_ID,
|
||||
"source_ref": SOURCE_REF,
|
||||
"object_key": "weknora/10008/assets/image.png",
|
||||
"content_type": "image/png",
|
||||
"created_at": CREATED_AT,
|
||||
"status": "active",
|
||||
}
|
||||
)
|
||||
repository = AssetRepository(pool=FakeAssetPool(connection))
|
||||
|
||||
mapping = await repository.get_or_create(
|
||||
source_ref=SOURCE_REF,
|
||||
object_key="weknora/10008/assets/image.png",
|
||||
content_type="image/png",
|
||||
)
|
||||
|
||||
assert mapping == AssetMapping(
|
||||
asset_id=ASSET_ID,
|
||||
source_ref=SOURCE_REF,
|
||||
object_key="weknora/10008/assets/image.png",
|
||||
content_type="image/png",
|
||||
created_at=CREATED_AT,
|
||||
status="active",
|
||||
)
|
||||
generated_asset_id = connection.args[0]
|
||||
assert isinstance(generated_asset_id, UUID)
|
||||
assert generated_asset_id.version == 4
|
||||
assert connection.args[1:] == (
|
||||
SOURCE_REF,
|
||||
"weknora/10008/assets/image.png",
|
||||
"image/png",
|
||||
)
|
||||
sql = " ".join(connection.query.lower().split())
|
||||
assert "insert into asset_mapping" in sql
|
||||
assert "(asset_id, source_ref, object_key, content_type, status)" in sql
|
||||
assert "values ($1, $2, $3, $4, 'active')" in sql
|
||||
assert "on conflict (source_ref) do update" in sql
|
||||
assert "source_ref = asset_mapping.source_ref" in sql
|
||||
assert "where asset_mapping.object_key = excluded.object_key" in sql
|
||||
assert (
|
||||
"returning asset_id, source_ref, object_key, content_type, created_at, status" in sql
|
||||
)
|
||||
|
||||
|
||||
async def test_get_or_create_rejects_source_ref_object_key_conflict() -> None:
|
||||
repository = AssetRepository(pool=FakeAssetPool(FakeAssetConnection(None)))
|
||||
|
||||
with pytest.raises(AssetMappingConflictError, match=r"^asset mapping conflict$"):
|
||||
await repository.get_or_create(
|
||||
source_ref=SOURCE_REF,
|
||||
object_key="different/object.png",
|
||||
content_type="image/png",
|
||||
)
|
||||
|
||||
|
||||
async def test_get_or_create_maps_database_error_to_safe_error() -> None:
|
||||
repository = AssetRepository(
|
||||
pool=FakeAssetPool(FailingAssetConnection(None)),
|
||||
)
|
||||
|
||||
with pytest.raises(AssetRepositoryError) as captured:
|
||||
await repository.get_or_create(
|
||||
source_ref=SOURCE_REF,
|
||||
object_key="weknora/10008/assets/image.png",
|
||||
content_type="image/png",
|
||||
)
|
||||
|
||||
assert str(captured.value) == "asset repository unavailable"
|
||||
assert "postgresql" not in str(captured.value)
|
||||
assert "object_key" not in str(captured.value)
|
||||
|
||||
|
||||
async def test_get_active_by_source_ref_reads_only_active_mapping() -> None:
|
||||
connection = FakeAssetConnection(
|
||||
{
|
||||
"asset_id": ASSET_ID,
|
||||
"source_ref": SOURCE_REF,
|
||||
"object_key": "weknora/10008/assets/image.png",
|
||||
"content_type": "image/png",
|
||||
"created_at": CREATED_AT,
|
||||
"status": "active",
|
||||
}
|
||||
)
|
||||
repository = AssetRepository(pool=FakeAssetPool(connection))
|
||||
|
||||
mapping = await repository.get_active_by_source_ref(SOURCE_REF)
|
||||
|
||||
assert mapping is not None
|
||||
assert mapping.asset_id == ASSET_ID
|
||||
assert connection.args == (SOURCE_REF,)
|
||||
sql = " ".join(connection.query.lower().split())
|
||||
assert sql.startswith(
|
||||
"select asset_id, source_ref, object_key, content_type, created_at, status "
|
||||
"from asset_mapping"
|
||||
)
|
||||
assert "source_ref = $1" in sql
|
||||
assert "status = 'active'" in sql
|
||||
|
||||
|
||||
async def test_get_active_by_source_ref_returns_none_when_missing() -> None:
|
||||
repository = AssetRepository(pool=FakeAssetPool(FakeAssetConnection(None)))
|
||||
|
||||
mapping = await repository.get_active_by_source_ref(SOURCE_REF)
|
||||
|
||||
assert mapping is None
|
||||
|
||||
|
||||
async def test_get_active_by_source_ref_maps_database_error_to_safe_error() -> None:
|
||||
repository = AssetRepository(
|
||||
pool=FakeAssetPool(FailingAssetConnection(None)),
|
||||
)
|
||||
|
||||
with pytest.raises(AssetRepositoryError, match=r"^asset repository unavailable$"):
|
||||
await repository.get_active_by_source_ref(SOURCE_REF)
|
||||
|
||||
|
||||
async def test_get_active_by_asset_id_reads_only_active_mapping() -> None:
|
||||
connection = FakeAssetConnection(
|
||||
{
|
||||
"asset_id": ASSET_ID,
|
||||
"source_ref": SOURCE_REF,
|
||||
"object_key": "weknora/10008/assets/image.png",
|
||||
"content_type": "image/png",
|
||||
"created_at": CREATED_AT,
|
||||
"status": "active",
|
||||
}
|
||||
)
|
||||
repository = AssetRepository(pool=FakeAssetPool(connection))
|
||||
|
||||
mapping = await repository.get_active_by_asset_id(ASSET_ID)
|
||||
|
||||
assert mapping is not None
|
||||
assert mapping.object_key == "weknora/10008/assets/image.png"
|
||||
assert connection.args == (ASSET_ID,)
|
||||
sql = " ".join(connection.query.lower().split())
|
||||
assert "from asset_mapping" in sql
|
||||
assert "asset_id = $1" in sql
|
||||
assert "status = 'active'" in sql
|
||||
|
||||
|
||||
async def test_get_active_by_asset_id_returns_none_when_missing() -> None:
|
||||
repository = AssetRepository(pool=FakeAssetPool(FakeAssetConnection(None)))
|
||||
|
||||
mapping = await repository.get_active_by_asset_id(ASSET_ID)
|
||||
|
||||
assert mapping is None
|
||||
@@ -0,0 +1,127 @@
|
||||
from uuid import UUID
|
||||
|
||||
import httpx
|
||||
|
||||
from knowledge_adapter.app import create_app
|
||||
from knowledge_adapter.asset_redirect import (
|
||||
AssetNotFoundError,
|
||||
AssetRedirectUnavailableError,
|
||||
)
|
||||
|
||||
ASSET_ID = UUID("c7f61f89-19ce-45b1-ac60-dbeed5e2a491")
|
||||
SIGNED_URL = (
|
||||
"https://private-assets.oss-cn-shenzhen.aliyuncs.com/"
|
||||
"weknora/10008/assets/image.png?x-oss-signature=redacted"
|
||||
)
|
||||
|
||||
|
||||
class RecordingRedirectService:
|
||||
def __init__(
|
||||
self,
|
||||
url: str = SIGNED_URL,
|
||||
*,
|
||||
error: Exception | None = None,
|
||||
) -> None:
|
||||
self.url = url
|
||||
self.error = error
|
||||
self.calls: list[UUID] = []
|
||||
|
||||
async def get_redirect_url(self, asset_id: UUID) -> str:
|
||||
self.calls.append(asset_id)
|
||||
if self.error is not None:
|
||||
raise self.error
|
||||
return self.url
|
||||
|
||||
|
||||
async def test_asset_route_returns_anonymous_302() -> None:
|
||||
service = RecordingRedirectService()
|
||||
app = create_app(asset_redirect_service=service)
|
||||
transport = httpx.ASGITransport(app=app)
|
||||
|
||||
async with httpx.AsyncClient(
|
||||
transport=transport,
|
||||
base_url="http://test",
|
||||
follow_redirects=False,
|
||||
) as client:
|
||||
response = await client.get(f"/i/{ASSET_ID}")
|
||||
|
||||
assert response.status_code == 302
|
||||
assert response.headers["location"] == SIGNED_URL
|
||||
assert response.headers["cache-control"] == "no-store"
|
||||
assert response.headers["referrer-policy"] == "no-referrer"
|
||||
assert response.content == b""
|
||||
assert service.calls == [ASSET_ID]
|
||||
|
||||
|
||||
async def test_asset_route_returns_empty_404_for_unknown_asset() -> None:
|
||||
service = RecordingRedirectService(error=AssetNotFoundError("asset not found"))
|
||||
app = create_app(asset_redirect_service=service)
|
||||
transport = httpx.ASGITransport(app=app, raise_app_exceptions=False)
|
||||
|
||||
async with httpx.AsyncClient(transport=transport, base_url="http://test") as client:
|
||||
response = await client.get(f"/i/{ASSET_ID}")
|
||||
|
||||
assert response.status_code == 404
|
||||
assert response.content == b""
|
||||
assert "asset" not in response.text.lower()
|
||||
assert str(ASSET_ID) not in response.text
|
||||
|
||||
|
||||
async def test_asset_route_rejects_malformed_uuid_before_service() -> None:
|
||||
service = RecordingRedirectService()
|
||||
app = create_app(asset_redirect_service=service)
|
||||
transport = httpx.ASGITransport(app=app)
|
||||
|
||||
async with httpx.AsyncClient(transport=transport, base_url="http://test") as client:
|
||||
response = await client.get("/i/not-a-uuid")
|
||||
|
||||
assert response.status_code == 404
|
||||
assert response.content == b""
|
||||
assert service.calls == []
|
||||
|
||||
|
||||
async def test_asset_route_returns_empty_503_when_redirect_is_unavailable() -> None:
|
||||
service = RecordingRedirectService(
|
||||
error=AssetRedirectUnavailableError(
|
||||
"metadata http://100.100.100.200?token=secret object_key=private/image.png"
|
||||
)
|
||||
)
|
||||
app = create_app(asset_redirect_service=service)
|
||||
transport = httpx.ASGITransport(app=app, raise_app_exceptions=False)
|
||||
|
||||
async with httpx.AsyncClient(transport=transport, base_url="http://test") as client:
|
||||
response = await client.get(f"/i/{ASSET_ID}")
|
||||
|
||||
assert response.status_code == 503
|
||||
assert response.content == b""
|
||||
assert "100.100.100.200" not in response.text
|
||||
assert "object_key" not in response.text
|
||||
assert "secret" not in response.text
|
||||
|
||||
|
||||
async def test_asset_route_does_not_accept_bucket_object_key_or_url_overrides() -> None:
|
||||
service = RecordingRedirectService()
|
||||
app = create_app(asset_redirect_service=service)
|
||||
transport = httpx.ASGITransport(app=app)
|
||||
|
||||
async with httpx.AsyncClient(
|
||||
transport=transport,
|
||||
base_url="http://test",
|
||||
follow_redirects=False,
|
||||
) as client:
|
||||
response = await client.get(
|
||||
f"/i/{ASSET_ID}",
|
||||
params={
|
||||
"bucket": "attacker-bucket",
|
||||
"object_key": "other/secret.png",
|
||||
"url": "https://attacker.example/file",
|
||||
},
|
||||
headers={
|
||||
"X-OSS-Bucket": "attacker-bucket",
|
||||
"X-Object-Key": "other/secret.png",
|
||||
},
|
||||
)
|
||||
|
||||
assert response.status_code == 302
|
||||
assert response.headers["location"] == SIGNED_URL
|
||||
assert service.calls == [ASSET_ID]
|
||||
@@ -0,0 +1,91 @@
|
||||
import hashlib
|
||||
import hmac
|
||||
from collections.abc import AsyncIterator
|
||||
|
||||
import httpx
|
||||
import pytest
|
||||
|
||||
from knowledge_adapter.app import create_app
|
||||
from knowledge_adapter.auth import DifyKeyAuthenticator
|
||||
|
||||
CURRENT_KEY = "c" * 32
|
||||
NEXT_KEY = "n" * 32
|
||||
VALID_PAYLOAD = {
|
||||
"knowledge_id": "3904b40e-278b-4273-a6fa-db6cbc975587",
|
||||
"query": "test query",
|
||||
"retrieval_setting": {"top_k": 3, "score_threshold": 0.5},
|
||||
}
|
||||
|
||||
|
||||
def sha256_hex(value: str) -> str:
|
||||
return hashlib.sha256(value.encode()).hexdigest()
|
||||
|
||||
|
||||
@pytest.fixture
|
||||
async def client() -> AsyncIterator[httpx.AsyncClient]:
|
||||
authenticator = DifyKeyAuthenticator(
|
||||
current_hash=sha256_hex(CURRENT_KEY),
|
||||
next_hash=sha256_hex(NEXT_KEY),
|
||||
)
|
||||
transport = httpx.ASGITransport(app=create_app(authenticator=authenticator))
|
||||
async with httpx.AsyncClient(transport=transport, base_url="http://test") as value:
|
||||
yield value
|
||||
|
||||
|
||||
async def test_retrieval_without_bearer_key_returns_401(client: httpx.AsyncClient) -> None:
|
||||
response = await client.post("/retrieval", json=VALID_PAYLOAD)
|
||||
|
||||
assert response.status_code == 401
|
||||
|
||||
|
||||
async def test_retrieval_with_wrong_bearer_key_returns_401(client: httpx.AsyncClient) -> None:
|
||||
response = await client.post(
|
||||
"/retrieval",
|
||||
headers={"Authorization": f"Bearer {'x' * 32}"},
|
||||
json=VALID_PAYLOAD,
|
||||
)
|
||||
|
||||
assert response.status_code == 401
|
||||
|
||||
|
||||
async def test_retrieval_with_current_key_returns_200(client: httpx.AsyncClient) -> None:
|
||||
response = await client.post(
|
||||
"/retrieval",
|
||||
headers={"Authorization": f"Bearer {CURRENT_KEY}"},
|
||||
json=VALID_PAYLOAD,
|
||||
)
|
||||
|
||||
assert response.status_code == 200
|
||||
|
||||
|
||||
async def test_retrieval_with_next_key_returns_200(client: httpx.AsyncClient) -> None:
|
||||
response = await client.post(
|
||||
"/retrieval",
|
||||
headers={"Authorization": f"Bearer {NEXT_KEY}"},
|
||||
json=VALID_PAYLOAD,
|
||||
)
|
||||
|
||||
assert response.status_code == 200
|
||||
|
||||
|
||||
async def test_current_match_does_not_short_circuit_next_hash_comparison(
|
||||
client: httpx.AsyncClient,
|
||||
monkeypatch: pytest.MonkeyPatch,
|
||||
) -> None:
|
||||
original_compare = hmac.compare_digest
|
||||
compared_hashes: list[str] = []
|
||||
|
||||
def recording_compare(digest: str, configured_hash: str) -> bool:
|
||||
compared_hashes.append(configured_hash)
|
||||
return original_compare(digest, configured_hash)
|
||||
|
||||
monkeypatch.setattr("knowledge_adapter.auth.hmac.compare_digest", recording_compare)
|
||||
|
||||
response = await client.post(
|
||||
"/retrieval",
|
||||
headers={"Authorization": f"Bearer {CURRENT_KEY}"},
|
||||
json=VALID_PAYLOAD,
|
||||
)
|
||||
|
||||
assert response.status_code == 200
|
||||
assert len(compared_hashes) == 2
|
||||
@@ -0,0 +1,34 @@
|
||||
from knowledge_adapter.content_budget import TRUNCATION_MARKER, truncate_content
|
||||
|
||||
|
||||
def test_plain_content_is_truncated_with_explicit_marker() -> None:
|
||||
limit = len(TRUNCATION_MARKER) + 5
|
||||
|
||||
result = truncate_content("abcdefghij" * 10, max_chars=limit)
|
||||
|
||||
assert result == f"abcde{TRUNCATION_MARKER}"
|
||||
assert len(result) == limit
|
||||
|
||||
|
||||
def test_truncation_never_splits_markdown_image_node() -> None:
|
||||
content = (
|
||||
"prefix "
|
||||
""
|
||||
" trailing text"
|
||||
)
|
||||
limit = len(TRUNCATION_MARKER) + len("prefix 
|
||||
|
||||
result = truncate_content(content, max_chars=limit)
|
||||
|
||||
assert result == f"prefix {TRUNCATION_MARKER}"
|
||||
assert len(result) <= limit
|
||||
|
||||
|
||||
def test_truncation_never_splits_fenced_code_block() -> None:
|
||||
content = "intro\n```python\nprint('sensitive')\n```\n" + ("after" * 20)
|
||||
limit = len(TRUNCATION_MARKER) + len("intro\n```python\nprint")
|
||||
|
||||
result = truncate_content(content, max_chars=limit)
|
||||
|
||||
assert result == f"intro\n{TRUNCATION_MARKER}"
|
||||
assert result.count("```") == 0
|
||||
@@ -0,0 +1,218 @@
|
||||
import json
|
||||
from pathlib import Path
|
||||
|
||||
ROOT = Path(__file__).resolve().parents[1]
|
||||
|
||||
|
||||
def test_dockerfile_is_reproducible_non_root_and_secret_free() -> None:
|
||||
dockerfile = (ROOT / "Dockerfile").read_text(encoding="utf-8")
|
||||
|
||||
assert "python:3.12.11-slim-bookworm" in dockerfile
|
||||
assert "uv sync --frozen --no-dev --no-editable" in dockerfile
|
||||
assert "USER 10001:10001" in dockerfile
|
||||
assert "knowledge_adapter.entrypoint:create_production_app" in dockerfile
|
||||
assert "--factory" in dockerfile
|
||||
assert "--no-access-log" in dockerfile
|
||||
assert "--host\", \"0.0.0.0\"" in dockerfile
|
||||
assert "--port\", \"8080\"" in dockerfile
|
||||
for forbidden in (
|
||||
"WEKNORA_API_KEY=",
|
||||
"OSS_ACCESS_KEY_ID",
|
||||
"OSS_ACCESS_KEY_SECRET",
|
||||
"ALIBABA_CLOUD_ACCESS_KEY",
|
||||
):
|
||||
assert forbidden not in dockerfile
|
||||
|
||||
|
||||
def test_compose_is_hardened_and_mounts_only_secret_files() -> None:
|
||||
compose = (ROOT / "deploy/docker-compose.adapter.yml").read_text(encoding="utf-8")
|
||||
|
||||
for required in (
|
||||
'"127.0.0.1:18080:8080"',
|
||||
'user: "10001:10001"',
|
||||
"read_only: true",
|
||||
"no-new-privileges:true",
|
||||
"cap_drop:",
|
||||
"- ALL",
|
||||
"pids_limit: 256",
|
||||
"tmpfs:",
|
||||
"healthcheck:",
|
||||
"WEKNORA_API_KEY_FILE: /run/secrets/weknora_api_key",
|
||||
"ASSET_DATABASE_URL_FILE: /run/secrets/asset_database_url",
|
||||
"WEKNORA_READONLY_DATABASE_URL_FILE: /run/secrets/weknora_readonly_database_url",
|
||||
'OSS_CREDENTIAL_MODE: "${OSS_CREDENTIAL_MODE:-static_ak}"',
|
||||
"OSS_ACCESS_KEY_ID_FILE: /run/secrets/oss_access_key_id",
|
||||
"OSS_ACCESS_KEY_SECRET_FILE: /run/secrets/oss_access_key_secret",
|
||||
"- adapter",
|
||||
"- weknora_upstream",
|
||||
"weknora_upstream:",
|
||||
"external: true",
|
||||
'name: "${WEKNORA_NETWORK_NAME:?set WEKNORA_NETWORK_NAME}"',
|
||||
"target: /run/secrets/weknora_api_key",
|
||||
"target: /run/secrets/asset_database_url",
|
||||
"target: /run/secrets/weknora_readonly_database_url",
|
||||
"target: /run/secrets/oss_access_key_id",
|
||||
"target: /run/secrets/oss_access_key_secret",
|
||||
"read_only: true",
|
||||
):
|
||||
assert required in compose
|
||||
for forbidden in (
|
||||
"WEKNORA_API_KEY:",
|
||||
"OSS_ACCESS_KEY_ID:",
|
||||
"OSS_ACCESS_KEY_SECRET:",
|
||||
"ALIBABA_CLOUD_ACCESS_KEY",
|
||||
"/var/run/docker.sock",
|
||||
"postgres:",
|
||||
"redis:",
|
||||
):
|
||||
assert forbidden not in compose
|
||||
|
||||
|
||||
def test_nginx_config_enforces_tls_methods_limits_and_safe_logging() -> None:
|
||||
nginx = (ROOT / "deploy/nginx/knowledge-adapter.conf").read_text(encoding="utf-8")
|
||||
|
||||
for required in (
|
||||
"listen 443 ssl;",
|
||||
"server_name assets.example.com;",
|
||||
"ssl_protocols TLSv1.2 TLSv1.3;",
|
||||
"access_log off;",
|
||||
"proxy_pass http://127.0.0.1:18080;",
|
||||
"proxy_set_header X-Request-ID $adapter_request_id;",
|
||||
"proxy_intercept_errors off;",
|
||||
"client_max_body_size 64k;",
|
||||
"limit_req zone=adapter_retrieval",
|
||||
"location = /retrieval",
|
||||
"limit_except POST",
|
||||
"location ~ ^/i/",
|
||||
"limit_except GET",
|
||||
"location = /healthz",
|
||||
"return 404;",
|
||||
):
|
||||
assert required in nginx
|
||||
for forbidden in (
|
||||
"$request_uri",
|
||||
"$args",
|
||||
"$upstream_http_location",
|
||||
"proxy_set_header X-OSS",
|
||||
):
|
||||
assert forbidden not in nginx
|
||||
|
||||
|
||||
def test_ram_policy_is_get_only_and_prefix_scoped() -> None:
|
||||
policy_path = ROOT / "deploy/ram/knowledge-adapter-oss-read-policy.json"
|
||||
policy = json.loads(policy_path.read_text(encoding="utf-8"))
|
||||
|
||||
assert policy["Version"] == "1"
|
||||
assert len(policy["Statement"]) == 1
|
||||
statement = policy["Statement"][0]
|
||||
assert statement == {
|
||||
"Effect": "Allow",
|
||||
"Action": ["oss:GetObject"],
|
||||
"Resource": [
|
||||
"acs:oss:*:*:${OSS_BUCKET}/weknora/${WEKNORA_TENANT_ID}/*"
|
||||
],
|
||||
}
|
||||
serialized = json.dumps(policy, sort_keys=True)
|
||||
for forbidden in (
|
||||
"oss:List",
|
||||
"oss:Put",
|
||||
"oss:Delete",
|
||||
"kms:Decrypt",
|
||||
):
|
||||
assert forbidden not in serialized
|
||||
|
||||
|
||||
def test_delivery_docs_and_makefile_cover_required_review_gates() -> None:
|
||||
architecture = (ROOT / "docs/architecture.md").read_text(encoding="utf-8")
|
||||
security = (ROOT / "docs/security.md").read_text(encoding="utf-8")
|
||||
deployment = (ROOT / "docs/deployment.md").read_text(encoding="utf-8")
|
||||
rotation = (ROOT / "docs/key-rotation.md").read_text(encoding="utf-8")
|
||||
makefile = (ROOT / "Makefile").read_text(encoding="utf-8")
|
||||
|
||||
for required in (
|
||||
"POST /retrieval",
|
||||
"GET /i/{UUID}",
|
||||
"GET /healthz",
|
||||
"WeKnora",
|
||||
"asset_mapping",
|
||||
"Private OSS",
|
||||
"static AK Secret files",
|
||||
"600",
|
||||
):
|
||||
assert required in architecture
|
||||
for required in (
|
||||
"static AK",
|
||||
"oss:GetObject",
|
||||
"Private",
|
||||
"Presigned URL",
|
||||
"0400",
|
||||
"Authorization",
|
||||
"object_key",
|
||||
"SSRF",
|
||||
"## Sources",
|
||||
):
|
||||
assert required in security
|
||||
for required in (
|
||||
"TEST ENVIRONMENT ONLY",
|
||||
"Production deployment is prohibited",
|
||||
"docker compose config",
|
||||
"migration",
|
||||
"rollback",
|
||||
"0400",
|
||||
"10001",
|
||||
"healthz",
|
||||
"OSS_ACCESS_KEY_ID_HOST_FILE",
|
||||
"OSS_ACCESS_KEY_SECRET_HOST_FILE",
|
||||
):
|
||||
assert required in deployment
|
||||
for required in (
|
||||
"DIFY_KEY_HASH_CURRENT",
|
||||
"DIFY_KEY_HASH_NEXT",
|
||||
"WeKnora API Key",
|
||||
"Adapter DB",
|
||||
"WeKnora read-only DB",
|
||||
"OSS static AK",
|
||||
"rollback",
|
||||
):
|
||||
assert required in rotation
|
||||
for required in (
|
||||
"test-slice8:",
|
||||
"lint:",
|
||||
"compose-config:",
|
||||
"check:",
|
||||
):
|
||||
assert required in makefile
|
||||
for forbidden in ("sudo", " down -v", " compose up"):
|
||||
assert forbidden not in makefile
|
||||
|
||||
|
||||
def test_git_and_docker_context_ignore_secret_material() -> None:
|
||||
gitignore = (ROOT / ".gitignore").read_text(encoding="utf-8").splitlines()
|
||||
dockerignore = (ROOT / ".dockerignore").read_text(encoding="utf-8").splitlines()
|
||||
|
||||
for pattern in (".env", "secrets/", "*.secret", "*.key", "*.pem"):
|
||||
assert pattern in gitignore
|
||||
assert pattern in dockerignore
|
||||
|
||||
|
||||
def test_slice9_audit_report_distinguishes_pass_blocked_and_not_run() -> None:
|
||||
report = (ROOT / "docs/audit-report-slice9.md").read_text(encoding="utf-8")
|
||||
|
||||
for required in (
|
||||
"133 passed",
|
||||
"All checks passed!",
|
||||
"WeKnora /health",
|
||||
"PASS",
|
||||
"BLOCKED",
|
||||
"NOT RUN",
|
||||
"Docker daemon permission",
|
||||
"nginx binary unavailable",
|
||||
"ECS RAM Role",
|
||||
"Dify → Adapter → WeKnora → Adapter DB → OSS",
|
||||
"Private OSS anonymous denial",
|
||||
"600-second expiry",
|
||||
"stable UUID re-signing",
|
||||
"Production deployment",
|
||||
):
|
||||
assert required in report
|
||||
assert "Real cloud E2E | PASS" not in report
|
||||
@@ -0,0 +1,22 @@
|
||||
from typing import Any
|
||||
|
||||
|
||||
def test_entrypoint_builds_production_app_from_environment(
|
||||
monkeypatch: Any,
|
||||
) -> None:
|
||||
import knowledge_adapter.entrypoint as entrypoint
|
||||
|
||||
settings = object()
|
||||
application = object()
|
||||
calls: list[object] = []
|
||||
|
||||
monkeypatch.setattr(entrypoint, "Settings", lambda: settings)
|
||||
|
||||
def build(settings_value: object) -> object:
|
||||
calls.append(settings_value)
|
||||
return application
|
||||
|
||||
monkeypatch.setattr(entrypoint, "build_production_app", build)
|
||||
|
||||
assert entrypoint.create_production_app() is application
|
||||
assert calls == [settings]
|
||||
@@ -0,0 +1,632 @@
|
||||
import hashlib
|
||||
from collections.abc import AsyncIterator
|
||||
from contextlib import asynccontextmanager
|
||||
from datetime import UTC, datetime
|
||||
from pathlib import Path
|
||||
from unittest.mock import AsyncMock
|
||||
from urllib.parse import parse_qs, urlparse
|
||||
|
||||
import asyncpg
|
||||
import httpx
|
||||
import pytest
|
||||
from alibabacloud_credentials.models import CredentialModel
|
||||
from pydantic import SecretStr
|
||||
|
||||
from knowledge_adapter.factory import build_app, build_production_app
|
||||
from knowledge_adapter.settings import Settings
|
||||
|
||||
DIFY_KEY = "f" * 32
|
||||
KB_ID = "3904b40e-278b-4273-a6fa-db6cbc975587"
|
||||
|
||||
|
||||
@pytest.fixture(autouse=True)
|
||||
def stub_weknora_api_key_file(monkeypatch: pytest.MonkeyPatch) -> None:
|
||||
monkeypatch.setattr(
|
||||
Settings,
|
||||
"read_weknora_api_key",
|
||||
lambda _settings: SecretStr("test-weknora-key"),
|
||||
)
|
||||
|
||||
|
||||
@pytest.fixture
|
||||
async def configured_client() -> AsyncIterator[httpx.AsyncClient]:
|
||||
settings = Settings(
|
||||
DIFY_KEY_HASH_CURRENT=hashlib.sha256(DIFY_KEY.encode()).hexdigest(),
|
||||
DIFY_KEY_HASH_NEXT="",
|
||||
WEKNORA_BASE_URL="http://weknora.internal:8080",
|
||||
WEKNORA_ALLOWED_KB_IDS=KB_ID,
|
||||
WEKNORA_TENANT_ID=10008,
|
||||
WEKNORA_OSS_STORAGE_BACKEND_ID="backend-test",
|
||||
OSS_REGION="cn-shenzhen",
|
||||
OSS_BUCKET="private-assets",
|
||||
OSS_RAM_ROLE_NAME="knowledge-adapter-role",
|
||||
ASSET_PUBLIC_BASE_URL="https://assets.example.com",
|
||||
MAX_QUERY_CHARS=5,
|
||||
)
|
||||
|
||||
def handler(_request: httpx.Request) -> httpx.Response:
|
||||
return httpx.Response(200, json={"success": True, "data": []})
|
||||
|
||||
app = build_app(settings, weknora_transport=httpx.MockTransport(handler))
|
||||
transport = httpx.ASGITransport(app=app)
|
||||
async with httpx.AsyncClient(transport=transport, base_url="http://test") as client:
|
||||
yield client
|
||||
await app.state.weknora_client.aclose()
|
||||
|
||||
|
||||
async def test_build_app_wires_settings_and_retrieval_service(
|
||||
configured_client: httpx.AsyncClient,
|
||||
) -> None:
|
||||
response = await configured_client.post(
|
||||
"/retrieval",
|
||||
headers={"Authorization": f"Bearer {DIFY_KEY}"},
|
||||
json={
|
||||
"knowledge_id": KB_ID,
|
||||
"query": "12345",
|
||||
"retrieval_setting": {"top_k": 1, "score_threshold": 0},
|
||||
},
|
||||
)
|
||||
|
||||
assert response.status_code == 200
|
||||
assert response.json() == {"records": []}
|
||||
|
||||
|
||||
async def test_build_app_uses_configured_query_limit(
|
||||
configured_client: httpx.AsyncClient,
|
||||
) -> None:
|
||||
response = await configured_client.post(
|
||||
"/retrieval",
|
||||
headers={"Authorization": f"Bearer {DIFY_KEY}"},
|
||||
json={
|
||||
"knowledge_id": KB_ID,
|
||||
"query": "123456",
|
||||
"retrieval_setting": {"top_k": 1, "score_threshold": 0},
|
||||
},
|
||||
)
|
||||
|
||||
assert response.status_code == 400
|
||||
|
||||
|
||||
async def test_app_lifespan_closes_weknora_client() -> None:
|
||||
settings = Settings(
|
||||
DIFY_KEY_HASH_CURRENT=hashlib.sha256(DIFY_KEY.encode()).hexdigest(),
|
||||
DIFY_KEY_HASH_NEXT="",
|
||||
WEKNORA_BASE_URL="http://weknora.internal:8080",
|
||||
WEKNORA_ALLOWED_KB_IDS=KB_ID,
|
||||
WEKNORA_TENANT_ID=10008,
|
||||
WEKNORA_OSS_STORAGE_BACKEND_ID="backend-test",
|
||||
OSS_REGION="cn-shenzhen",
|
||||
OSS_BUCKET="private-assets",
|
||||
OSS_RAM_ROLE_NAME="knowledge-adapter-role",
|
||||
ASSET_PUBLIC_BASE_URL="https://assets.example.com",
|
||||
)
|
||||
app = build_app(
|
||||
settings,
|
||||
weknora_transport=httpx.MockTransport(
|
||||
lambda _request: httpx.Response(200, json={"success": True, "data": []})
|
||||
),
|
||||
)
|
||||
close_mock = AsyncMock()
|
||||
app.state.weknora_client.aclose = close_mock
|
||||
|
||||
async with app.router.lifespan_context(app):
|
||||
pass
|
||||
|
||||
close_mock.assert_awaited_once_with()
|
||||
|
||||
|
||||
async def test_build_app_passes_configured_max_top_k_to_service() -> None:
|
||||
settings = Settings(
|
||||
DIFY_KEY_HASH_CURRENT=hashlib.sha256(DIFY_KEY.encode()).hexdigest(),
|
||||
DIFY_KEY_HASH_NEXT="",
|
||||
WEKNORA_BASE_URL="http://weknora.internal:8080",
|
||||
WEKNORA_ALLOWED_KB_IDS=KB_ID,
|
||||
WEKNORA_TENANT_ID=10008,
|
||||
WEKNORA_OSS_STORAGE_BACKEND_ID="backend-test",
|
||||
OSS_REGION="cn-shenzhen",
|
||||
OSS_BUCKET="private-assets",
|
||||
OSS_RAM_ROLE_NAME="knowledge-adapter-role",
|
||||
ASSET_PUBLIC_BASE_URL="https://assets.example.com",
|
||||
MAX_TOP_K=1,
|
||||
)
|
||||
base_chunk = {
|
||||
"score": 0.9,
|
||||
"knowledge_base_id": KB_ID,
|
||||
"knowledge_id": "6f77a258-27ff-4278-a667-8fe242ff8e10",
|
||||
"knowledge_title": "Manual",
|
||||
"knowledge_filename": "manual.pdf",
|
||||
"chunk_type": "text",
|
||||
"image_info": "",
|
||||
}
|
||||
|
||||
def handler(_request: httpx.Request) -> httpx.Response:
|
||||
return httpx.Response(
|
||||
200,
|
||||
json={
|
||||
"success": True,
|
||||
"data": [
|
||||
{
|
||||
**base_chunk,
|
||||
"id": "c7f61f89-19ce-45b1-ac60-dbeed5e2a491",
|
||||
"content": "first",
|
||||
"chunk_index": 0,
|
||||
},
|
||||
{
|
||||
**base_chunk,
|
||||
"id": "09ab721f-7d05-45de-ae0f-dac303276f6d",
|
||||
"content": "second",
|
||||
"chunk_index": 1,
|
||||
},
|
||||
],
|
||||
},
|
||||
)
|
||||
|
||||
app = build_app(settings, weknora_transport=httpx.MockTransport(handler))
|
||||
transport = httpx.ASGITransport(app=app)
|
||||
async with app.router.lifespan_context(app):
|
||||
async with httpx.AsyncClient(transport=transport, base_url="http://test") as client:
|
||||
response = await client.post(
|
||||
"/retrieval",
|
||||
headers={"Authorization": f"Bearer {DIFY_KEY}"},
|
||||
json={
|
||||
"knowledge_id": KB_ID,
|
||||
"query": "query",
|
||||
"retrieval_setting": {"top_k": 100, "score_threshold": 0},
|
||||
},
|
||||
)
|
||||
|
||||
assert response.status_code == 200
|
||||
assert [record["content"] for record in response.json()["records"]] == ["first"]
|
||||
|
||||
|
||||
async def test_build_app_passes_configured_content_budgets_to_service() -> None:
|
||||
settings = Settings(
|
||||
DIFY_KEY_HASH_CURRENT=hashlib.sha256(DIFY_KEY.encode()).hexdigest(),
|
||||
DIFY_KEY_HASH_NEXT="",
|
||||
WEKNORA_BASE_URL="http://weknora.internal:8080",
|
||||
WEKNORA_ALLOWED_KB_IDS=KB_ID,
|
||||
WEKNORA_TENANT_ID=10008,
|
||||
WEKNORA_OSS_STORAGE_BACKEND_ID="backend-test",
|
||||
OSS_REGION="cn-shenzhen",
|
||||
OSS_BUCKET="private-assets",
|
||||
OSS_RAM_ROLE_NAME="knowledge-adapter-role",
|
||||
ASSET_PUBLIC_BASE_URL="https://assets.example.com",
|
||||
MAX_CHUNK_CHARS=50,
|
||||
MAX_TOTAL_CHARS=70,
|
||||
)
|
||||
base_chunk = {
|
||||
"score": 0.9,
|
||||
"knowledge_base_id": KB_ID,
|
||||
"knowledge_id": "6f77a258-27ff-4278-a667-8fe242ff8e10",
|
||||
"knowledge_title": "Manual",
|
||||
"knowledge_filename": "manual.pdf",
|
||||
"chunk_type": "text",
|
||||
"image_info": "",
|
||||
}
|
||||
|
||||
def handler(_request: httpx.Request) -> httpx.Response:
|
||||
return httpx.Response(
|
||||
200,
|
||||
json={
|
||||
"success": True,
|
||||
"data": [
|
||||
{
|
||||
**base_chunk,
|
||||
"id": "c7f61f89-19ce-45b1-ac60-dbeed5e2a491",
|
||||
"content": "a" * 100,
|
||||
"chunk_index": 0,
|
||||
},
|
||||
{
|
||||
**base_chunk,
|
||||
"id": "09ab721f-7d05-45de-ae0f-dac303276f6d",
|
||||
"content": "b" * 100,
|
||||
"chunk_index": 1,
|
||||
},
|
||||
],
|
||||
},
|
||||
)
|
||||
|
||||
app = build_app(settings, weknora_transport=httpx.MockTransport(handler))
|
||||
transport = httpx.ASGITransport(app=app)
|
||||
async with app.router.lifespan_context(app):
|
||||
async with httpx.AsyncClient(transport=transport, base_url="http://test") as client:
|
||||
response = await client.post(
|
||||
"/retrieval",
|
||||
headers={"Authorization": f"Bearer {DIFY_KEY}"},
|
||||
json={
|
||||
"knowledge_id": KB_ID,
|
||||
"query": "query",
|
||||
"retrieval_setting": {"top_k": 5, "score_threshold": 0},
|
||||
},
|
||||
)
|
||||
|
||||
records = response.json()["records"]
|
||||
assert response.status_code == 200
|
||||
assert len(records) == 1
|
||||
assert len(records[0]["content"]) == 50
|
||||
|
||||
|
||||
class FakeRuntimePool:
|
||||
def __init__(self, connection: object | None = None) -> None:
|
||||
self.connection = connection
|
||||
self.closed = False
|
||||
|
||||
@asynccontextmanager
|
||||
async def acquire(self) -> AsyncIterator[object]:
|
||||
if self.connection is None:
|
||||
raise AssertionError("pool acquire was not expected")
|
||||
yield self.connection
|
||||
|
||||
async def close(self) -> None:
|
||||
self.closed = True
|
||||
|
||||
|
||||
class RecordingPoolFactory:
|
||||
def __init__(self, pools: list[FakeRuntimePool] | None = None) -> None:
|
||||
self.calls: list[dict[str, object]] = []
|
||||
self.pools = pools or [FakeRuntimePool(), FakeRuntimePool()]
|
||||
|
||||
async def __call__(self, **kwargs: object) -> FakeRuntimePool:
|
||||
self.calls.append(kwargs)
|
||||
return self.pools[len(self.calls) - 1]
|
||||
|
||||
|
||||
async def test_production_factory_creates_separate_bounded_pools(
|
||||
tmp_path: Path,
|
||||
) -> None:
|
||||
asset_secret = tmp_path / "asset-db-url"
|
||||
weknora_secret = tmp_path / "weknora-db-url"
|
||||
asset_secret.write_text("postgresql://adapter-test\n", encoding="utf-8")
|
||||
weknora_secret.write_text("postgresql://weknora-readonly-test\n", encoding="utf-8")
|
||||
settings = Settings(
|
||||
DIFY_KEY_HASH_CURRENT=hashlib.sha256(DIFY_KEY.encode()).hexdigest(),
|
||||
DIFY_KEY_HASH_NEXT="",
|
||||
WEKNORA_BASE_URL="http://weknora.internal:8080",
|
||||
WEKNORA_ALLOWED_KB_IDS=KB_ID,
|
||||
WEKNORA_TENANT_ID=10008,
|
||||
WEKNORA_OSS_STORAGE_BACKEND_ID="backend-test",
|
||||
weknora_readonly_database_url_file=weknora_secret,
|
||||
asset_database_url_file=asset_secret,
|
||||
OSS_REGION="cn-shenzhen",
|
||||
OSS_BUCKET="private-assets",
|
||||
OSS_RAM_ROLE_NAME="knowledge-adapter-role",
|
||||
ASSET_PUBLIC_BASE_URL="https://assets.example.com",
|
||||
)
|
||||
pool_factory = RecordingPoolFactory()
|
||||
app = build_production_app(
|
||||
settings,
|
||||
pool_factory=pool_factory,
|
||||
weknora_transport=httpx.MockTransport(
|
||||
lambda _request: httpx.Response(200, json={"success": True, "data": []})
|
||||
),
|
||||
)
|
||||
|
||||
async with app.router.lifespan_context(app):
|
||||
assert len(pool_factory.calls) == 2
|
||||
asset_call, weknora_call = pool_factory.calls
|
||||
assert asset_call == {
|
||||
"dsn": "postgresql://adapter-test",
|
||||
"min_size": 1,
|
||||
"max_size": 5,
|
||||
"command_timeout": 5,
|
||||
"server_settings": {"statement_timeout": "5000"},
|
||||
}
|
||||
assert weknora_call == {
|
||||
"dsn": "postgresql://weknora-readonly-test",
|
||||
"min_size": 1,
|
||||
"max_size": 2,
|
||||
"command_timeout": 1,
|
||||
"server_settings": {
|
||||
"default_transaction_read_only": "on",
|
||||
"statement_timeout": "1000",
|
||||
},
|
||||
}
|
||||
assert not any(pool.closed for pool in pool_factory.pools)
|
||||
|
||||
assert all(pool.closed for pool in pool_factory.pools)
|
||||
|
||||
|
||||
class RuntimeAdapterConnection:
|
||||
def __init__(self) -> None:
|
||||
self.queries: list[tuple[str, tuple[object, ...]]] = []
|
||||
|
||||
async def fetchrow(self, query: str, *args: object) -> dict[str, object] | None:
|
||||
self.queries.append((query, args))
|
||||
if query.lstrip().startswith("SELECT"):
|
||||
return None
|
||||
return {
|
||||
"asset_id": "c7f61f89-19ce-45b1-ac60-dbeed5e2a491",
|
||||
"source_ref": args[1],
|
||||
"object_key": args[2],
|
||||
"content_type": args[3],
|
||||
"created_at": datetime(2026, 8, 24, tzinfo=UTC),
|
||||
"status": "active",
|
||||
}
|
||||
|
||||
|
||||
class RuntimeWeKnoraConnection:
|
||||
def __init__(self) -> None:
|
||||
self.readonly_transactions: list[bool] = []
|
||||
self.fetch_calls: list[tuple[str, tuple[object, ...]]] = []
|
||||
|
||||
@asynccontextmanager
|
||||
async def transaction(self, *, readonly: bool) -> AsyncIterator[None]:
|
||||
self.readonly_transactions.append(readonly)
|
||||
yield
|
||||
|
||||
async def fetch(self, query: str, *args: object) -> list[dict[str, object]]:
|
||||
self.fetch_calls.append((query, args))
|
||||
return [
|
||||
{
|
||||
"tenant_id": 10008,
|
||||
"storage_backend_id": "backend-test",
|
||||
"provider": "oss",
|
||||
"physical_path": (
|
||||
"storage://backend-test/"
|
||||
"oss://private-assets/weknora/10008/assets/image.png"
|
||||
),
|
||||
"mime_type": "image/png",
|
||||
}
|
||||
]
|
||||
|
||||
|
||||
async def test_production_factory_wires_first_image_resolution_flow(
|
||||
tmp_path: Path,
|
||||
) -> None:
|
||||
source_ref = "resource://AbCdEfGhIjKlMnOpQrSt_1"
|
||||
asset_secret = tmp_path / "asset-db-url"
|
||||
weknora_secret = tmp_path / "weknora-db-url"
|
||||
asset_secret.write_text("postgresql://adapter-test\n", encoding="utf-8")
|
||||
weknora_secret.write_text("postgresql://weknora-readonly-test\n", encoding="utf-8")
|
||||
settings = Settings(
|
||||
DIFY_KEY_HASH_CURRENT=hashlib.sha256(DIFY_KEY.encode()).hexdigest(),
|
||||
DIFY_KEY_HASH_NEXT="",
|
||||
WEKNORA_BASE_URL="http://weknora.internal:8080",
|
||||
WEKNORA_ALLOWED_KB_IDS=KB_ID,
|
||||
WEKNORA_TENANT_ID=10008,
|
||||
WEKNORA_OSS_STORAGE_BACKEND_ID="backend-test",
|
||||
weknora_readonly_database_url_file=weknora_secret,
|
||||
asset_database_url_file=asset_secret,
|
||||
OSS_REGION="cn-shenzhen",
|
||||
OSS_BUCKET="private-assets",
|
||||
OSS_RAM_ROLE_NAME="knowledge-adapter-role",
|
||||
ASSET_PUBLIC_BASE_URL="https://assets.example.com",
|
||||
)
|
||||
adapter_connection = RuntimeAdapterConnection()
|
||||
weknora_connection = RuntimeWeKnoraConnection()
|
||||
pool_factory = RecordingPoolFactory(
|
||||
[FakeRuntimePool(adapter_connection), FakeRuntimePool(weknora_connection)]
|
||||
)
|
||||
|
||||
def handler(_request: httpx.Request) -> httpx.Response:
|
||||
return httpx.Response(
|
||||
200,
|
||||
json={
|
||||
"success": True,
|
||||
"data": [
|
||||
{
|
||||
"id": "09ab721f-7d05-45de-ae0f-dac303276f6d",
|
||||
"content": f"",
|
||||
"score": 0.9,
|
||||
"knowledge_base_id": KB_ID,
|
||||
"knowledge_id": "6f77a258-27ff-4278-a667-8fe242ff8e10",
|
||||
"knowledge_title": "Manual",
|
||||
"knowledge_filename": "manual.pdf",
|
||||
"chunk_index": 0,
|
||||
"chunk_type": "text",
|
||||
"image_info": "[]",
|
||||
}
|
||||
],
|
||||
},
|
||||
)
|
||||
|
||||
app = build_production_app(
|
||||
settings,
|
||||
pool_factory=pool_factory,
|
||||
weknora_transport=httpx.MockTransport(handler),
|
||||
)
|
||||
transport = httpx.ASGITransport(app=app)
|
||||
async with app.router.lifespan_context(app):
|
||||
async with httpx.AsyncClient(transport=transport, base_url="http://test") as client:
|
||||
response = await client.post(
|
||||
"/retrieval",
|
||||
headers={"Authorization": f"Bearer {DIFY_KEY}"},
|
||||
json={
|
||||
"knowledge_id": KB_ID,
|
||||
"query": "query",
|
||||
"retrieval_setting": {"top_k": 1, "score_threshold": 0},
|
||||
},
|
||||
)
|
||||
|
||||
assert response.status_code == 200
|
||||
assert response.json()["records"][0]["content"] == (
|
||||
""
|
||||
)
|
||||
assert source_ref not in response.text
|
||||
assert "weknora/10008/assets/image.png" not in response.text
|
||||
assert len(adapter_connection.queries) == 2
|
||||
assert weknora_connection.readonly_transactions == [True]
|
||||
assert len(weknora_connection.fetch_calls) == 1
|
||||
|
||||
|
||||
async def test_production_factory_defaults_to_asyncpg_pool_factory(
|
||||
tmp_path: Path,
|
||||
monkeypatch: pytest.MonkeyPatch,
|
||||
) -> None:
|
||||
asset_secret = tmp_path / "asset-db-url"
|
||||
weknora_secret = tmp_path / "weknora-db-url"
|
||||
asset_secret.write_text("postgresql://adapter-test\n", encoding="utf-8")
|
||||
weknora_secret.write_text("postgresql://weknora-readonly-test\n", encoding="utf-8")
|
||||
settings = Settings(
|
||||
DIFY_KEY_HASH_CURRENT=hashlib.sha256(DIFY_KEY.encode()).hexdigest(),
|
||||
DIFY_KEY_HASH_NEXT="",
|
||||
WEKNORA_BASE_URL="http://weknora.internal:8080",
|
||||
WEKNORA_ALLOWED_KB_IDS=KB_ID,
|
||||
WEKNORA_TENANT_ID=10008,
|
||||
WEKNORA_OSS_STORAGE_BACKEND_ID="backend-test",
|
||||
weknora_readonly_database_url_file=weknora_secret,
|
||||
asset_database_url_file=asset_secret,
|
||||
OSS_REGION="cn-shenzhen",
|
||||
OSS_BUCKET="private-assets",
|
||||
OSS_RAM_ROLE_NAME="knowledge-adapter-role",
|
||||
ASSET_PUBLIC_BASE_URL="https://assets.example.com",
|
||||
)
|
||||
pool_factory = RecordingPoolFactory()
|
||||
monkeypatch.setattr(asyncpg, "create_pool", pool_factory)
|
||||
|
||||
app = build_production_app(
|
||||
settings,
|
||||
weknora_transport=httpx.MockTransport(
|
||||
lambda _request: httpx.Response(200, json={"success": True, "data": []})
|
||||
),
|
||||
)
|
||||
async with app.router.lifespan_context(app):
|
||||
pass
|
||||
|
||||
assert len(pool_factory.calls) == 2
|
||||
assert all(pool.closed for pool in pool_factory.pools)
|
||||
|
||||
|
||||
class RuntimeAssetLookupConnection(RuntimeAdapterConnection):
|
||||
async def fetchrow(self, query: str, *args: object) -> dict[str, object] | None:
|
||||
self.queries.append((query, args))
|
||||
return {
|
||||
"asset_id": "c7f61f89-19ce-45b1-ac60-dbeed5e2a491",
|
||||
"source_ref": "resource://AbCdEfGhIjKlMnOpQrSt_1",
|
||||
"object_key": "weknora/10008/assets/image.png",
|
||||
"content_type": "image/png",
|
||||
"created_at": datetime(2026, 8, 24, tzinfo=UTC),
|
||||
"status": "active",
|
||||
}
|
||||
|
||||
|
||||
class FactoryCredentialClient:
|
||||
def get_credential(self) -> CredentialModel:
|
||||
return CredentialModel(
|
||||
access_key_id="test-access-key-id",
|
||||
access_key_secret="test-access-key-secret",
|
||||
security_token="test-security-token",
|
||||
type="ecs_ram_role",
|
||||
)
|
||||
|
||||
|
||||
async def test_production_factory_wires_anonymous_asset_redirect(
|
||||
tmp_path: Path,
|
||||
) -> None:
|
||||
asset_secret = tmp_path / "asset-db-url"
|
||||
weknora_secret = tmp_path / "weknora-db-url"
|
||||
asset_secret.write_text("postgresql://adapter-test\n", encoding="utf-8")
|
||||
weknora_secret.write_text("postgresql://weknora-readonly-test\n", encoding="utf-8")
|
||||
settings = Settings(
|
||||
DIFY_KEY_HASH_CURRENT=hashlib.sha256(DIFY_KEY.encode()).hexdigest(),
|
||||
DIFY_KEY_HASH_NEXT="",
|
||||
WEKNORA_BASE_URL="http://weknora.internal:8080",
|
||||
WEKNORA_ALLOWED_KB_IDS=KB_ID,
|
||||
WEKNORA_TENANT_ID=10008,
|
||||
WEKNORA_OSS_STORAGE_BACKEND_ID="backend-test",
|
||||
weknora_readonly_database_url_file=weknora_secret,
|
||||
asset_database_url_file=asset_secret,
|
||||
OSS_REGION="cn-shenzhen",
|
||||
OSS_BUCKET="private-assets",
|
||||
OSS_RAM_ROLE_NAME="knowledge-adapter-role",
|
||||
ASSET_PUBLIC_BASE_URL="https://assets.example.com",
|
||||
)
|
||||
adapter_connection = RuntimeAssetLookupConnection()
|
||||
pool_factory = RecordingPoolFactory(
|
||||
[FakeRuntimePool(adapter_connection), FakeRuntimePool(RuntimeWeKnoraConnection())]
|
||||
)
|
||||
role_names: list[str] = []
|
||||
|
||||
def credential_client_factory(role_name: str) -> FactoryCredentialClient:
|
||||
role_names.append(role_name)
|
||||
return FactoryCredentialClient()
|
||||
|
||||
app = build_production_app(
|
||||
settings,
|
||||
pool_factory=pool_factory,
|
||||
credential_client_factory=credential_client_factory,
|
||||
weknora_transport=httpx.MockTransport(
|
||||
lambda _request: httpx.Response(200, json={"success": True, "data": []})
|
||||
),
|
||||
)
|
||||
transport = httpx.ASGITransport(app=app)
|
||||
async with app.router.lifespan_context(app):
|
||||
async with httpx.AsyncClient(
|
||||
transport=transport,
|
||||
base_url="http://test",
|
||||
follow_redirects=False,
|
||||
) as client:
|
||||
response = await client.get(
|
||||
"/i/c7f61f89-19ce-45b1-ac60-dbeed5e2a491"
|
||||
)
|
||||
|
||||
location = urlparse(response.headers["location"])
|
||||
query = parse_qs(location.query)
|
||||
assert response.status_code == 302
|
||||
assert location.scheme == "https"
|
||||
assert location.hostname == "private-assets.oss-cn-shenzhen.aliyuncs.com"
|
||||
assert query["x-oss-signature-version"] == ["OSS4-HMAC-SHA256"]
|
||||
assert query["x-oss-expires"] == ["600"]
|
||||
assert role_names == ["knowledge-adapter-role"]
|
||||
assert len(adapter_connection.queries) == 1
|
||||
|
||||
|
||||
async def test_production_factory_uses_static_ak_secret_files(
|
||||
tmp_path: Path,
|
||||
) -> None:
|
||||
asset_secret = tmp_path / "asset-db-url"
|
||||
weknora_secret = tmp_path / "weknora-db-url"
|
||||
access_key_id_file = tmp_path / "oss-access-key-id"
|
||||
access_key_secret_file = tmp_path / "oss-access-key-secret"
|
||||
asset_secret.write_text("postgresql://adapter-test\n", encoding="utf-8")
|
||||
weknora_secret.write_text("postgresql://weknora-readonly-test\n", encoding="utf-8")
|
||||
access_key_id_file.write_text("test-access-key-id\n", encoding="utf-8")
|
||||
access_key_secret_file.write_text("test-access-key-secret\n", encoding="utf-8")
|
||||
settings = Settings(
|
||||
DIFY_KEY_HASH_CURRENT=hashlib.sha256(DIFY_KEY.encode()).hexdigest(),
|
||||
DIFY_KEY_HASH_NEXT="",
|
||||
WEKNORA_BASE_URL="http://weknora.internal:8080",
|
||||
WEKNORA_ALLOWED_KB_IDS=KB_ID,
|
||||
WEKNORA_TENANT_ID=10008,
|
||||
WEKNORA_OSS_STORAGE_BACKEND_ID="backend-test",
|
||||
weknora_readonly_database_url_file=weknora_secret,
|
||||
asset_database_url_file=asset_secret,
|
||||
OSS_REGION="cn-shenzhen",
|
||||
OSS_BUCKET="private-assets",
|
||||
OSS_CREDENTIAL_MODE="static_ak",
|
||||
OSS_ACCESS_KEY_ID_FILE=access_key_id_file,
|
||||
OSS_ACCESS_KEY_SECRET_FILE=access_key_secret_file,
|
||||
ASSET_PUBLIC_BASE_URL="https://assets.example.com",
|
||||
)
|
||||
adapter_connection = RuntimeAssetLookupConnection()
|
||||
pool_factory = RecordingPoolFactory(
|
||||
[FakeRuntimePool(adapter_connection), FakeRuntimePool(RuntimeWeKnoraConnection())]
|
||||
)
|
||||
|
||||
def unexpected_ram_role_factory(_role_name: str) -> FactoryCredentialClient:
|
||||
raise AssertionError("RAM role factory must not be used in static AK mode")
|
||||
|
||||
app = build_production_app(
|
||||
settings,
|
||||
pool_factory=pool_factory,
|
||||
credential_client_factory=unexpected_ram_role_factory,
|
||||
weknora_transport=httpx.MockTransport(
|
||||
lambda _request: httpx.Response(200, json={"success": True, "data": []})
|
||||
),
|
||||
)
|
||||
transport = httpx.ASGITransport(app=app)
|
||||
async with app.router.lifespan_context(app):
|
||||
async with httpx.AsyncClient(
|
||||
transport=transport,
|
||||
base_url="http://test",
|
||||
follow_redirects=False,
|
||||
) as client:
|
||||
response = await client.get("/i/c7f61f89-19ce-45b1-ac60-dbeed5e2a491")
|
||||
|
||||
location = urlparse(response.headers["location"])
|
||||
query = parse_qs(location.query)
|
||||
assert response.status_code == 302
|
||||
assert location.hostname == "private-assets.oss-cn-shenzhen.aliyuncs.com"
|
||||
assert query["x-oss-signature-version"] == ["OSS4-HMAC-SHA256"]
|
||||
assert "x-oss-security-token" not in query
|
||||
@@ -0,0 +1,27 @@
|
||||
from collections.abc import AsyncIterator
|
||||
|
||||
import httpx
|
||||
import pytest
|
||||
|
||||
from knowledge_adapter.app import create_app
|
||||
|
||||
|
||||
@pytest.fixture
|
||||
async def client() -> AsyncIterator[httpx.AsyncClient]:
|
||||
transport = httpx.ASGITransport(app=create_app())
|
||||
async with httpx.AsyncClient(transport=transport, base_url="http://test") as value:
|
||||
yield value
|
||||
|
||||
|
||||
async def test_healthz_reports_only_adapter_liveness(client: httpx.AsyncClient) -> None:
|
||||
response = await client.get("/healthz")
|
||||
|
||||
assert response.status_code == 200
|
||||
assert response.json() == {"status": "ok"}
|
||||
assert set(response.headers) >= {"content-type"}
|
||||
|
||||
|
||||
async def test_api_documentation_is_not_exposed(client: httpx.AsyncClient) -> None:
|
||||
for path in ("/docs", "/redoc", "/openapi.json"):
|
||||
response = await client.get(path)
|
||||
assert response.status_code == 404
|
||||
@@ -0,0 +1,41 @@
|
||||
from pathlib import Path
|
||||
|
||||
PROJECT_ROOT = Path(__file__).resolve().parents[1]
|
||||
UP_MIGRATION = PROJECT_ROOT / "migrations" / "0001_asset_mapping.up.sql"
|
||||
DOWN_MIGRATION = PROJECT_ROOT / "migrations" / "0001_asset_mapping.down.sql"
|
||||
|
||||
|
||||
def normalized_sql(path: Path) -> str:
|
||||
return " ".join(path.read_text(encoding="utf-8").lower().split())
|
||||
|
||||
|
||||
def test_asset_mapping_up_migration_has_minimal_idempotent_schema() -> None:
|
||||
assert UP_MIGRATION.exists(), "asset_mapping up migration is missing"
|
||||
|
||||
sql = normalized_sql(UP_MIGRATION)
|
||||
assert "create table if not exists asset_mapping" in sql
|
||||
assert "asset_id uuid primary key" in sql
|
||||
assert "source_ref text not null" in sql
|
||||
assert "object_key text not null" in sql
|
||||
assert "content_type text" in sql
|
||||
assert "created_at timestamptz not null default current_timestamp" in sql
|
||||
assert "status text not null default 'active'" in sql
|
||||
assert "check (status in ('active', 'disabled'))" in sql
|
||||
assert "create unique index if not exists" in sql
|
||||
assert "on asset_mapping (source_ref)" in sql
|
||||
|
||||
for forbidden_identifier in (
|
||||
"presigned_url",
|
||||
"access_key",
|
||||
"secret_key",
|
||||
"authorization",
|
||||
"bucket",
|
||||
):
|
||||
assert forbidden_identifier not in sql
|
||||
|
||||
|
||||
def test_asset_mapping_down_migration_is_idempotent_and_scoped() -> None:
|
||||
assert DOWN_MIGRATION.exists(), "asset_mapping down migration is missing"
|
||||
|
||||
sql = normalized_sql(DOWN_MIGRATION)
|
||||
assert sql == "drop table if exists asset_mapping;"
|
||||
@@ -0,0 +1,258 @@
|
||||
import json
|
||||
import logging
|
||||
from hashlib import sha256
|
||||
from uuid import UUID
|
||||
|
||||
import httpx
|
||||
from _pytest.logging import LogCaptureFixture
|
||||
from fastapi import HTTPException
|
||||
from pydantic import SecretStr
|
||||
|
||||
from knowledge_adapter.app import create_app
|
||||
from knowledge_adapter.auth import DifyKeyAuthenticator
|
||||
from knowledge_adapter.service import RetrievalService
|
||||
from knowledge_adapter.weknora_client import WeKnoraClient
|
||||
|
||||
|
||||
async def test_response_contains_generated_request_id() -> None:
|
||||
transport = httpx.ASGITransport(app=create_app())
|
||||
|
||||
async with httpx.AsyncClient(transport=transport, base_url="http://test") as client:
|
||||
response = await client.get("/healthz")
|
||||
|
||||
request_id = response.headers["x-request-id"]
|
||||
parsed = UUID(request_id)
|
||||
assert parsed.version == 4
|
||||
assert str(parsed) == request_id
|
||||
assert response.json() == {"status": "ok"}
|
||||
|
||||
|
||||
async def test_response_preserves_safe_inbound_request_id() -> None:
|
||||
transport = httpx.ASGITransport(app=create_app())
|
||||
inbound_request_id = "0123456789abcdef0123456789abcdef"
|
||||
|
||||
async with httpx.AsyncClient(transport=transport, base_url="http://test") as client:
|
||||
response = await client.get(
|
||||
"/healthz",
|
||||
headers={"X-Request-ID": inbound_request_id},
|
||||
)
|
||||
|
||||
assert response.headers["x-request-id"] == inbound_request_id
|
||||
|
||||
|
||||
async def test_response_replaces_unsafe_inbound_request_id() -> None:
|
||||
transport = httpx.ASGITransport(app=create_app())
|
||||
unsafe_request_id = "authorization bearer secret value"
|
||||
|
||||
async with httpx.AsyncClient(transport=transport, base_url="http://test") as client:
|
||||
response = await client.get(
|
||||
"/healthz",
|
||||
headers={"X-Request-ID": unsafe_request_id},
|
||||
)
|
||||
|
||||
request_id = response.headers["x-request-id"]
|
||||
assert UUID(request_id).version == 4
|
||||
assert unsafe_request_id not in request_id
|
||||
|
||||
|
||||
async def test_request_log_is_structured_and_uses_route_template(
|
||||
caplog: LogCaptureFixture,
|
||||
) -> None:
|
||||
request_id = "request-123"
|
||||
transport = httpx.ASGITransport(app=create_app())
|
||||
|
||||
with caplog.at_level(logging.INFO, logger="knowledge_adapter.http"):
|
||||
async with httpx.AsyncClient(transport=transport, base_url="http://test") as client:
|
||||
response = await client.get(
|
||||
"/healthz?api_key=must-not-appear",
|
||||
headers={"X-Request-ID": request_id},
|
||||
)
|
||||
|
||||
records = [
|
||||
record
|
||||
for record in caplog.records
|
||||
if record.name == "knowledge_adapter.http"
|
||||
]
|
||||
assert len(records) == 1
|
||||
event = json.loads(records[0].getMessage())
|
||||
assert set(event) == {
|
||||
"duration_ms",
|
||||
"event",
|
||||
"method",
|
||||
"request_id",
|
||||
"route",
|
||||
"status_code",
|
||||
}
|
||||
assert event["event"] == "http_request"
|
||||
assert event["request_id"] == request_id
|
||||
assert event["method"] == "GET"
|
||||
assert event["route"] == "/healthz"
|
||||
assert event["status_code"] == response.status_code == 200
|
||||
assert isinstance(event["duration_ms"], int)
|
||||
assert event["duration_ms"] >= 0
|
||||
assert "must-not-appear" not in records[0].getMessage()
|
||||
|
||||
|
||||
class ExplodingRetrievalService:
|
||||
async def retrieve(self, _request: object) -> dict[str, object]:
|
||||
raise RuntimeError(
|
||||
"Authorization: Bearer server-secret "
|
||||
"resource://AbCdEfGhIjKlMnOpQrSt_1 "
|
||||
"object_key=weknora/10008/private.png "
|
||||
"https://private-assets.oss-cn-shenzhen.aliyuncs.com/private.png?"
|
||||
"x-oss-signature=server-secret"
|
||||
)
|
||||
|
||||
|
||||
async def test_unhandled_exception_is_safe_traceable_and_redacted(
|
||||
caplog: LogCaptureFixture,
|
||||
) -> None:
|
||||
dify_key = "client-secret"
|
||||
request_id = "request-error-123"
|
||||
authenticator = DifyKeyAuthenticator(
|
||||
current_hash=sha256(dify_key.encode()).hexdigest()
|
||||
)
|
||||
app = create_app(
|
||||
authenticator=authenticator,
|
||||
retrieval_service=ExplodingRetrievalService(), # type: ignore[arg-type]
|
||||
)
|
||||
transport = httpx.ASGITransport(app=app, raise_app_exceptions=False)
|
||||
|
||||
with caplog.at_level(logging.INFO, logger="knowledge_adapter.http"):
|
||||
async with httpx.AsyncClient(transport=transport, base_url="http://test") as client:
|
||||
response = await client.post(
|
||||
"/retrieval",
|
||||
headers={
|
||||
"Authorization": f"Bearer {dify_key}",
|
||||
"X-Request-ID": request_id,
|
||||
},
|
||||
json={
|
||||
"knowledge_id": "3904b40e-278b-4273-a6fa-db6cbc975587",
|
||||
"query": "sensitive customer knowledge",
|
||||
"retrieval_setting": {"top_k": 1, "score_threshold": 0},
|
||||
},
|
||||
)
|
||||
|
||||
assert response.status_code == 500
|
||||
assert response.headers["x-request-id"] == request_id
|
||||
assert response.json() == {"detail": "internal server error"}
|
||||
adapter_log = "\n".join(
|
||||
record.getMessage()
|
||||
for record in caplog.records
|
||||
if record.name.startswith("knowledge_adapter")
|
||||
)
|
||||
event = json.loads(adapter_log)
|
||||
assert event["route"] == "/retrieval"
|
||||
assert event["status_code"] == 500
|
||||
assert event["error_code"] == "internal_error"
|
||||
for forbidden in (
|
||||
dify_key,
|
||||
"server-secret",
|
||||
"sensitive customer knowledge",
|
||||
"resource://",
|
||||
"object_key",
|
||||
"private.png",
|
||||
"x-oss-signature",
|
||||
):
|
||||
assert forbidden not in response.text
|
||||
assert forbidden not in adapter_log
|
||||
|
||||
|
||||
async def test_unknown_route_uses_safe_uniform_404_without_logging_raw_path(
|
||||
caplog: LogCaptureFixture,
|
||||
) -> None:
|
||||
request_id = "request-not-found"
|
||||
raw_path_secret = "unknown-secret-path"
|
||||
transport = httpx.ASGITransport(app=create_app())
|
||||
|
||||
with caplog.at_level(logging.INFO, logger="knowledge_adapter.http"):
|
||||
async with httpx.AsyncClient(transport=transport, base_url="http://test") as client:
|
||||
response = await client.get(
|
||||
f"/{raw_path_secret}?authorization=server-secret",
|
||||
headers={"X-Request-ID": request_id},
|
||||
)
|
||||
|
||||
assert response.status_code == 404
|
||||
assert response.headers["x-request-id"] == request_id
|
||||
assert response.json() == {"detail": "not found"}
|
||||
adapter_log = "\n".join(
|
||||
record.getMessage()
|
||||
for record in caplog.records
|
||||
if record.name == "knowledge_adapter.http"
|
||||
)
|
||||
event = json.loads(adapter_log)
|
||||
assert event["route"] == "<unmatched>"
|
||||
assert raw_path_secret not in adapter_log
|
||||
assert "server-secret" not in adapter_log
|
||||
|
||||
|
||||
async def test_unknown_http_exception_detail_and_headers_are_redacted() -> None:
|
||||
app = create_app()
|
||||
|
||||
@app.get("/test-only-http-error")
|
||||
async def test_only_http_error() -> None:
|
||||
raise HTTPException(
|
||||
status_code=418,
|
||||
detail="Authorization Bearer server-secret resource://private",
|
||||
headers={"X-Internal-Secret": "server-secret"},
|
||||
)
|
||||
|
||||
transport = httpx.ASGITransport(app=app)
|
||||
async with httpx.AsyncClient(transport=transport, base_url="http://test") as client:
|
||||
response = await client.get("/test-only-http-error")
|
||||
|
||||
assert response.status_code == 418
|
||||
assert response.json() == {"detail": "request failed"}
|
||||
assert "x-internal-secret" not in response.headers
|
||||
assert "server-secret" not in response.text
|
||||
assert "resource://" not in response.text
|
||||
|
||||
|
||||
async def test_safe_request_id_is_forwarded_to_weknora() -> None:
|
||||
dify_key = "client-secret"
|
||||
request_id = "request-upstream-123"
|
||||
knowledge_base_id = UUID("3904b40e-278b-4273-a6fa-db6cbc975587")
|
||||
upstream_headers: list[httpx.Headers] = []
|
||||
|
||||
def handler(request: httpx.Request) -> httpx.Response:
|
||||
upstream_headers.append(request.headers)
|
||||
return httpx.Response(200, json={"success": True, "data": []})
|
||||
|
||||
weknora_client = WeKnoraClient(
|
||||
base_url="http://weknora.internal:8080",
|
||||
api_key=SecretStr("weknora-secret"),
|
||||
timeout_seconds=15,
|
||||
transport=httpx.MockTransport(handler),
|
||||
)
|
||||
service = RetrievalService(
|
||||
search_client=weknora_client,
|
||||
allowed_kb_ids=frozenset({knowledge_base_id}),
|
||||
)
|
||||
authenticator = DifyKeyAuthenticator(
|
||||
current_hash=sha256(dify_key.encode()).hexdigest()
|
||||
)
|
||||
app = create_app(authenticator=authenticator, retrieval_service=service)
|
||||
transport = httpx.ASGITransport(app=app)
|
||||
|
||||
try:
|
||||
async with httpx.AsyncClient(transport=transport, base_url="http://test") as client:
|
||||
response = await client.post(
|
||||
"/retrieval",
|
||||
headers={
|
||||
"Authorization": f"Bearer {dify_key}",
|
||||
"X-Request-ID": request_id,
|
||||
},
|
||||
json={
|
||||
"knowledge_id": str(knowledge_base_id),
|
||||
"query": "query",
|
||||
"retrieval_setting": {"top_k": 1, "score_threshold": 0},
|
||||
},
|
||||
)
|
||||
finally:
|
||||
await weknora_client.aclose()
|
||||
|
||||
assert response.status_code == 200
|
||||
assert len(upstream_headers) == 1
|
||||
assert upstream_headers[0]["x-request-id"] == request_id
|
||||
assert upstream_headers[0]["x-api-key"] == "weknora-secret"
|
||||
assert "authorization" not in upstream_headers[0]
|
||||
@@ -0,0 +1,150 @@
|
||||
from typing import ClassVar
|
||||
from urllib.parse import parse_qs, unquote, urlparse
|
||||
|
||||
import pytest
|
||||
from alibabacloud_credentials.models import Config, CredentialModel
|
||||
from pydantic import SecretStr
|
||||
|
||||
import knowledge_adapter.oss_signer as oss_signer_module
|
||||
from knowledge_adapter.asset_redirect import AssetSignerError
|
||||
from knowledge_adapter.oss_signer import (
|
||||
AlibabaOssV4Signer,
|
||||
create_ecs_ram_role_credential_client,
|
||||
)
|
||||
|
||||
|
||||
class RecordingCredentialClient:
|
||||
def __init__(self) -> None:
|
||||
self.calls = 0
|
||||
|
||||
def get_credential(self) -> CredentialModel:
|
||||
self.calls += 1
|
||||
return CredentialModel(
|
||||
access_key_id="test-access-key-id",
|
||||
access_key_secret="test-access-key-secret",
|
||||
security_token="test-security-token",
|
||||
type="ecs_ram_role",
|
||||
)
|
||||
|
||||
|
||||
async def test_oss_signer_generates_v4_temporary_get_url() -> None:
|
||||
credential_client = RecordingCredentialClient()
|
||||
signer = AlibabaOssV4Signer(
|
||||
credential_client=credential_client,
|
||||
region="cn-shenzhen",
|
||||
bucket="private-assets",
|
||||
)
|
||||
|
||||
signed_url = await signer.sign_get(
|
||||
object_key="weknora/10008/assets/image.png",
|
||||
expires_seconds=600,
|
||||
)
|
||||
|
||||
parsed = urlparse(signed_url)
|
||||
query = parse_qs(parsed.query)
|
||||
assert parsed.scheme == "https"
|
||||
assert parsed.hostname == "private-assets.oss-cn-shenzhen.aliyuncs.com"
|
||||
assert unquote(parsed.path) == "/weknora/10008/assets/image.png"
|
||||
assert query["x-oss-signature-version"] == ["OSS4-HMAC-SHA256"]
|
||||
assert query["x-oss-expires"] == ["600"]
|
||||
assert query["x-oss-security-token"] == ["test-security-token"]
|
||||
assert credential_client.calls == 1
|
||||
|
||||
|
||||
@pytest.mark.parametrize(
|
||||
("object_key", "expires_seconds"),
|
||||
[
|
||||
("../other-tenant/secret.png", 600),
|
||||
("weknora/10008/assets/image.png", 601),
|
||||
("weknora/10008/assets/image.png", 60),
|
||||
],
|
||||
)
|
||||
async def test_oss_signer_rejects_unsafe_key_or_ttl_before_credentials(
|
||||
object_key: str,
|
||||
expires_seconds: int,
|
||||
) -> None:
|
||||
credential_client = RecordingCredentialClient()
|
||||
signer = AlibabaOssV4Signer(
|
||||
credential_client=credential_client,
|
||||
region="cn-shenzhen",
|
||||
bucket="private-assets",
|
||||
)
|
||||
|
||||
with pytest.raises(AssetSignerError, match=r"^asset signing failed$"):
|
||||
await signer.sign_get(
|
||||
object_key=object_key,
|
||||
expires_seconds=expires_seconds,
|
||||
)
|
||||
|
||||
assert credential_client.calls == 0
|
||||
|
||||
|
||||
class UnsafeBucket:
|
||||
def sign_url(
|
||||
self,
|
||||
method: str,
|
||||
object_key: str,
|
||||
expires_seconds: int,
|
||||
) -> str:
|
||||
return "http://127.0.0.1/internal?x-oss-signature-version=OSS4-HMAC-SHA256"
|
||||
|
||||
|
||||
async def test_oss_signer_rejects_untrusted_signed_url() -> None:
|
||||
signer = AlibabaOssV4Signer(
|
||||
credential_client=RecordingCredentialClient(),
|
||||
region="cn-shenzhen",
|
||||
bucket="private-assets",
|
||||
)
|
||||
signer._bucket = UnsafeBucket()
|
||||
|
||||
with pytest.raises(AssetSignerError, match=r"^asset signing failed$"):
|
||||
await signer.sign_get(
|
||||
object_key="weknora/10008/assets/image.png",
|
||||
expires_seconds=600,
|
||||
)
|
||||
|
||||
|
||||
class RecordingCredentialsClientFactory:
|
||||
configs: ClassVar[list[Config]] = []
|
||||
|
||||
def __init__(self, config: Config) -> None:
|
||||
self.configs.append(config)
|
||||
|
||||
|
||||
async def test_ecs_ram_role_client_uses_imdsv2_without_static_keys(
|
||||
monkeypatch: pytest.MonkeyPatch,
|
||||
) -> None:
|
||||
RecordingCredentialsClientFactory.configs = []
|
||||
monkeypatch.setattr(
|
||||
oss_signer_module,
|
||||
"CredentialsClient",
|
||||
RecordingCredentialsClientFactory,
|
||||
)
|
||||
|
||||
create_ecs_ram_role_credential_client("knowledge-adapter-role")
|
||||
|
||||
assert len(RecordingCredentialsClientFactory.configs) == 1
|
||||
config = RecordingCredentialsClientFactory.configs[0]
|
||||
assert config.type == "ecs_ram_role"
|
||||
assert config.role_name == "knowledge-adapter-role"
|
||||
assert config.enable_imds_v2 is True
|
||||
assert config.disable_imds_v1 is True
|
||||
assert config.connect_timeout == 1000
|
||||
assert config.timeout == 1000
|
||||
assert not config.access_key_id
|
||||
assert not config.access_key_secret
|
||||
|
||||
|
||||
def test_static_ak_client_uses_secret_values_without_security_token() -> None:
|
||||
client = oss_signer_module.create_static_ak_credential_client(
|
||||
SecretStr("test-access-key-id"),
|
||||
SecretStr("test-access-key-secret"),
|
||||
)
|
||||
|
||||
credential = client.get_credential()
|
||||
|
||||
assert credential.access_key_id == "test-access-key-id"
|
||||
assert credential.access_key_secret == "test-access-key-secret"
|
||||
assert not credential.security_token
|
||||
assert credential.type == "access_key"
|
||||
assert "test-access-key-secret" not in repr(client)
|
||||
@@ -0,0 +1,110 @@
|
||||
import pytest
|
||||
|
||||
from knowledge_adapter.resource_locator import (
|
||||
InvalidResourceLocator,
|
||||
InvalidResourceReference,
|
||||
parse_oss_object_key,
|
||||
parse_resource_reference,
|
||||
)
|
||||
|
||||
VALID_HANDLE = "AbCdEfGhIjKlMnOpQrSt_1"
|
||||
|
||||
|
||||
def test_parse_resource_reference_accepts_only_canonical_handle() -> None:
|
||||
assert parse_resource_reference(f"resource://{VALID_HANDLE}") == VALID_HANDLE
|
||||
|
||||
invalid_values = [
|
||||
"resource://short",
|
||||
"resource://AbCdEfGhIjKlMnOpQrSt/1",
|
||||
"resource://AbCdEfGhIjKlMnOpQrSt%1",
|
||||
"https://example.com/image.png",
|
||||
"http://example.com/image.png",
|
||||
]
|
||||
for value in invalid_values:
|
||||
with pytest.raises(InvalidResourceReference):
|
||||
parse_resource_reference(value)
|
||||
|
||||
|
||||
def test_parse_oss_object_key_accepts_matching_wrapped_locator() -> None:
|
||||
object_key = parse_oss_object_key(
|
||||
provider="oss",
|
||||
physical_path=(
|
||||
"storage://backend-test/"
|
||||
"oss://private-assets/weknora/10008/assets/image.png"
|
||||
),
|
||||
storage_backend_id="backend-test",
|
||||
expected_storage_backend_id="backend-test",
|
||||
expected_bucket="private-assets",
|
||||
)
|
||||
|
||||
assert object_key == "weknora/10008/assets/image.png"
|
||||
|
||||
|
||||
@pytest.mark.parametrize(
|
||||
("provider", "physical_path", "storage_backend_id"),
|
||||
[
|
||||
(
|
||||
"oss",
|
||||
"storage://backend-test/oss://private-assets/../secret.png",
|
||||
"backend-test",
|
||||
),
|
||||
(
|
||||
"oss",
|
||||
"storage://backend-test/oss://private-assets//absolute.png",
|
||||
"backend-test",
|
||||
),
|
||||
(
|
||||
"oss",
|
||||
"storage://backend-test/oss://private-assets/folder\\image.png",
|
||||
"backend-test",
|
||||
),
|
||||
(
|
||||
"oss",
|
||||
"storage://backend-test/oss://private-assets/image.png\x00ignored",
|
||||
"backend-test",
|
||||
),
|
||||
(
|
||||
"oss",
|
||||
"storage://backend-test/oss://private-assets/image.png?signature=bad",
|
||||
"backend-test",
|
||||
),
|
||||
(
|
||||
"cos",
|
||||
"storage://backend-test/oss://private-assets/image.png",
|
||||
"backend-test",
|
||||
),
|
||||
(
|
||||
"oss",
|
||||
"storage://other/oss://private-assets/image.png",
|
||||
"backend-test",
|
||||
),
|
||||
(
|
||||
"oss",
|
||||
"storage://backend-test/oss://other-bucket/image.png",
|
||||
"backend-test",
|
||||
),
|
||||
(
|
||||
"oss",
|
||||
"https://example.com/image.png",
|
||||
"backend-test",
|
||||
),
|
||||
(
|
||||
"oss",
|
||||
"storage://backend-test/oss://private-assets/" + ("x" * 1024),
|
||||
"backend-test",
|
||||
),
|
||||
],
|
||||
)
|
||||
def test_parse_oss_object_key_rejects_locator_outside_fixed_boundary(
|
||||
provider: str,
|
||||
physical_path: str,
|
||||
storage_backend_id: str,
|
||||
) -> None:
|
||||
with pytest.raises(InvalidResourceLocator):
|
||||
parse_oss_object_key(
|
||||
provider=provider,
|
||||
physical_path=physical_path,
|
||||
storage_backend_id=storage_backend_id,
|
||||
expected_storage_backend_id="backend-test",
|
||||
expected_bucket="private-assets",
|
||||
)
|
||||
@@ -0,0 +1,269 @@
|
||||
import hashlib
|
||||
from collections.abc import AsyncIterator
|
||||
from uuid import UUID
|
||||
|
||||
import httpx
|
||||
import pytest
|
||||
|
||||
from knowledge_adapter.app import create_app
|
||||
from knowledge_adapter.asset_content_processor import ContentProcessingError
|
||||
from knowledge_adapter.auth import DifyKeyAuthenticator
|
||||
from knowledge_adapter.service import RetrievalService
|
||||
from knowledge_adapter.weknora_client import WeKnoraBadResponseError, WeKnoraUnavailableError
|
||||
|
||||
DIFY_KEY = "d" * 32
|
||||
ALLOWED_KB_ID = "3904b40e-278b-4273-a6fa-db6cbc975587"
|
||||
|
||||
|
||||
@pytest.fixture
|
||||
async def client() -> AsyncIterator[httpx.AsyncClient]:
|
||||
authenticator = DifyKeyAuthenticator(
|
||||
current_hash=hashlib.sha256(DIFY_KEY.encode()).hexdigest(),
|
||||
)
|
||||
transport = httpx.ASGITransport(app=create_app(authenticator=authenticator))
|
||||
async with httpx.AsyncClient(transport=transport, base_url="http://test") as value:
|
||||
yield value
|
||||
|
||||
|
||||
def auth_headers() -> dict[str, str]:
|
||||
return {"Authorization": f"Bearer {DIFY_KEY}"}
|
||||
|
||||
|
||||
def retrieval_payload(**overrides: object) -> dict[str, object]:
|
||||
payload: dict[str, object] = {
|
||||
"knowledge_id": ALLOWED_KB_ID,
|
||||
"query": "test query",
|
||||
"retrieval_setting": {"top_k": 3, "score_threshold": 0.5},
|
||||
}
|
||||
payload.update(overrides)
|
||||
return payload
|
||||
|
||||
|
||||
class RecordingSearchClient:
|
||||
def __init__(self) -> None:
|
||||
self.calls: list[tuple[str, UUID]] = []
|
||||
|
||||
async def search(self, *, query: str, knowledge_base_id: UUID) -> list[dict[str, object]]:
|
||||
self.calls.append((query, knowledge_base_id))
|
||||
return []
|
||||
|
||||
|
||||
class UnavailableSearchClient:
|
||||
async def search(self, *, query: str, knowledge_base_id: UUID) -> list[dict[str, object]]:
|
||||
raise WeKnoraUnavailableError("WeKnora unavailable")
|
||||
|
||||
|
||||
class BadResponseSearchClient:
|
||||
async def search(self, *, query: str, knowledge_base_id: UUID) -> list[dict[str, object]]:
|
||||
raise WeKnoraBadResponseError("invalid WeKnora response")
|
||||
|
||||
|
||||
class OneChunkSearchClient:
|
||||
async def search(self, *, query: str, knowledge_base_id: UUID) -> list[dict[str, object]]:
|
||||
return [
|
||||
{
|
||||
"id": "09ab721f-7d05-45de-ae0f-dac303276f6d",
|
||||
"content": "safe text",
|
||||
"score": 0.9,
|
||||
"knowledge_base_id": str(knowledge_base_id),
|
||||
"knowledge_id": "6f77a258-27ff-4278-a667-8fe242ff8e10",
|
||||
"knowledge_title": "Manual",
|
||||
"knowledge_filename": "manual.pdf",
|
||||
"chunk_index": 0,
|
||||
"chunk_type": "text",
|
||||
"image_info": "",
|
||||
}
|
||||
]
|
||||
|
||||
|
||||
class FailingContentProcessor:
|
||||
async def process(self, chunk: object) -> str:
|
||||
raise ContentProcessingError("content processing failed")
|
||||
|
||||
|
||||
async def test_valid_request_reaches_retrieval_service() -> None:
|
||||
search_client = RecordingSearchClient()
|
||||
service = RetrievalService(
|
||||
search_client=search_client,
|
||||
allowed_kb_ids=frozenset({UUID(ALLOWED_KB_ID)}),
|
||||
)
|
||||
authenticator = DifyKeyAuthenticator(
|
||||
current_hash=hashlib.sha256(DIFY_KEY.encode()).hexdigest(),
|
||||
)
|
||||
transport = httpx.ASGITransport(
|
||||
app=create_app(authenticator=authenticator, retrieval_service=service)
|
||||
)
|
||||
|
||||
async with httpx.AsyncClient(transport=transport, base_url="http://test") as app_client:
|
||||
response = await app_client.post(
|
||||
"/retrieval",
|
||||
headers=auth_headers(),
|
||||
json=retrieval_payload(query=" normalized query "),
|
||||
)
|
||||
|
||||
assert response.status_code == 200
|
||||
assert response.json() == {"records": []}
|
||||
assert search_client.calls == [("normalized query", UUID(ALLOWED_KB_ID))]
|
||||
|
||||
|
||||
async def test_disallowed_kb_returns_400_without_calling_upstream() -> None:
|
||||
search_client = RecordingSearchClient()
|
||||
service = RetrievalService(
|
||||
search_client=search_client,
|
||||
allowed_kb_ids=frozenset({UUID(ALLOWED_KB_ID)}),
|
||||
)
|
||||
authenticator = DifyKeyAuthenticator(
|
||||
current_hash=hashlib.sha256(DIFY_KEY.encode()).hexdigest(),
|
||||
)
|
||||
transport = httpx.ASGITransport(
|
||||
app=create_app(authenticator=authenticator, retrieval_service=service),
|
||||
raise_app_exceptions=False,
|
||||
)
|
||||
|
||||
async with httpx.AsyncClient(transport=transport, base_url="http://test") as app_client:
|
||||
response = await app_client.post(
|
||||
"/retrieval",
|
||||
headers=auth_headers(),
|
||||
json=retrieval_payload(knowledge_id="7fa6e8d2-05d8-4e74-b98c-d8591b680db9"),
|
||||
)
|
||||
|
||||
assert response.status_code == 400
|
||||
assert response.json() == {"detail": "invalid request"}
|
||||
assert search_client.calls == []
|
||||
|
||||
|
||||
async def test_weknora_timeout_returns_sanitized_503() -> None:
|
||||
service = RetrievalService(
|
||||
search_client=UnavailableSearchClient(),
|
||||
allowed_kb_ids=frozenset({UUID(ALLOWED_KB_ID)}),
|
||||
)
|
||||
authenticator = DifyKeyAuthenticator(
|
||||
current_hash=hashlib.sha256(DIFY_KEY.encode()).hexdigest(),
|
||||
)
|
||||
transport = httpx.ASGITransport(
|
||||
app=create_app(authenticator=authenticator, retrieval_service=service),
|
||||
raise_app_exceptions=False,
|
||||
)
|
||||
|
||||
async with httpx.AsyncClient(transport=transport, base_url="http://test") as app_client:
|
||||
response = await app_client.post(
|
||||
"/retrieval",
|
||||
headers=auth_headers(),
|
||||
json=retrieval_payload(),
|
||||
)
|
||||
|
||||
assert response.status_code == 503
|
||||
assert response.json() == {"detail": "upstream unavailable"}
|
||||
|
||||
|
||||
async def test_weknora_bad_response_returns_sanitized_502() -> None:
|
||||
service = RetrievalService(
|
||||
search_client=BadResponseSearchClient(),
|
||||
allowed_kb_ids=frozenset({UUID(ALLOWED_KB_ID)}),
|
||||
)
|
||||
authenticator = DifyKeyAuthenticator(
|
||||
current_hash=hashlib.sha256(DIFY_KEY.encode()).hexdigest(),
|
||||
)
|
||||
transport = httpx.ASGITransport(
|
||||
app=create_app(authenticator=authenticator, retrieval_service=service),
|
||||
raise_app_exceptions=False,
|
||||
)
|
||||
|
||||
async with httpx.AsyncClient(transport=transport, base_url="http://test") as app_client:
|
||||
response = await app_client.post(
|
||||
"/retrieval",
|
||||
headers=auth_headers(),
|
||||
json=retrieval_payload(),
|
||||
)
|
||||
|
||||
assert response.status_code == 502
|
||||
assert response.json() == {"detail": "invalid upstream response"}
|
||||
|
||||
|
||||
async def test_content_processing_failure_returns_sanitized_502() -> None:
|
||||
service = RetrievalService(
|
||||
search_client=OneChunkSearchClient(),
|
||||
allowed_kb_ids=frozenset({UUID(ALLOWED_KB_ID)}),
|
||||
content_processor=FailingContentProcessor(),
|
||||
)
|
||||
authenticator = DifyKeyAuthenticator(
|
||||
current_hash=hashlib.sha256(DIFY_KEY.encode()).hexdigest(),
|
||||
)
|
||||
transport = httpx.ASGITransport(
|
||||
app=create_app(authenticator=authenticator, retrieval_service=service),
|
||||
raise_app_exceptions=False,
|
||||
)
|
||||
|
||||
async with httpx.AsyncClient(transport=transport, base_url="http://test") as app_client:
|
||||
response = await app_client.post(
|
||||
"/retrieval",
|
||||
headers=auth_headers(),
|
||||
json=retrieval_payload(),
|
||||
)
|
||||
|
||||
assert response.status_code == 502
|
||||
assert response.json() == {"detail": "content processing failed"}
|
||||
|
||||
|
||||
async def test_empty_query_returns_400_without_echoing_query(client: httpx.AsyncClient) -> None:
|
||||
response = await client.post(
|
||||
"/retrieval",
|
||||
headers=auth_headers(),
|
||||
json=retrieval_payload(query=" "),
|
||||
)
|
||||
|
||||
assert response.status_code == 400
|
||||
assert "query" not in response.text.lower()
|
||||
|
||||
|
||||
async def test_invalid_json_returns_400(client: httpx.AsyncClient) -> None:
|
||||
response = await client.post(
|
||||
"/retrieval",
|
||||
headers={**auth_headers(), "Content-Type": "application/json"},
|
||||
content=b'{"query":',
|
||||
)
|
||||
|
||||
assert response.status_code == 400
|
||||
assert response.json() == {"detail": "invalid request"}
|
||||
|
||||
|
||||
async def test_query_over_maximum_returns_400_without_echoing_content(
|
||||
client: httpx.AsyncClient,
|
||||
) -> None:
|
||||
oversized_query = "敏" * 2001
|
||||
|
||||
response = await client.post(
|
||||
"/retrieval",
|
||||
headers=auth_headers(),
|
||||
json=retrieval_payload(query=oversized_query),
|
||||
)
|
||||
|
||||
assert response.status_code == 400
|
||||
assert oversized_query not in response.text
|
||||
|
||||
|
||||
async def test_user_cannot_supply_object_key_or_upstream_parameters(
|
||||
client: httpx.AsyncClient,
|
||||
) -> None:
|
||||
response = await client.post(
|
||||
"/retrieval",
|
||||
headers=auth_headers(),
|
||||
json=retrieval_payload(object_key="private/path.png"),
|
||||
)
|
||||
|
||||
assert response.status_code == 400
|
||||
|
||||
|
||||
async def test_nonempty_metadata_conditions_are_rejected(client: httpx.AsyncClient) -> None:
|
||||
response = await client.post(
|
||||
"/retrieval",
|
||||
headers=auth_headers(),
|
||||
json=retrieval_payload(
|
||||
metadata_condition={
|
||||
"logical_operator": "and",
|
||||
"conditions": [{"name": "product", "value": "secret"}],
|
||||
}
|
||||
),
|
||||
)
|
||||
|
||||
assert response.status_code == 400
|
||||
@@ -0,0 +1,302 @@
|
||||
from uuid import UUID
|
||||
|
||||
import pytest
|
||||
|
||||
from knowledge_adapter.content_budget import TRUNCATION_MARKER
|
||||
from knowledge_adapter.models import RetrievalRequest, WeKnoraChunk
|
||||
from knowledge_adapter.service import InvalidRequestError, RetrievalService
|
||||
|
||||
ALLOWED_KB_ID = UUID("3904b40e-278b-4273-a6fa-db6cbc975587")
|
||||
DENIED_KB_ID = UUID("7fa6e8d2-05d8-4e74-b98c-d8591b680db9")
|
||||
|
||||
|
||||
class RecordingSearchClient:
|
||||
def __init__(self, results: list[dict[str, object]] | None = None) -> None:
|
||||
self.calls: list[tuple[str, UUID]] = []
|
||||
self.results = results or []
|
||||
|
||||
async def search(self, *, query: str, knowledge_base_id: UUID) -> list[dict[str, object]]:
|
||||
self.calls.append((query, knowledge_base_id))
|
||||
return self.results
|
||||
|
||||
|
||||
class ExpandingContentProcessor:
|
||||
async def process(self, chunk: WeKnoraChunk) -> str:
|
||||
return chunk.content * 100
|
||||
|
||||
|
||||
def request_for(
|
||||
knowledge_id: UUID = ALLOWED_KB_ID,
|
||||
*,
|
||||
top_k: int = 3,
|
||||
score_threshold: float = 0.5,
|
||||
) -> RetrievalRequest:
|
||||
return RetrievalRequest.model_validate(
|
||||
{
|
||||
"knowledge_id": str(knowledge_id),
|
||||
"query": "test query",
|
||||
"retrieval_setting": {
|
||||
"top_k": top_k,
|
||||
"score_threshold": score_threshold,
|
||||
},
|
||||
}
|
||||
)
|
||||
|
||||
|
||||
async def test_disallowed_kb_is_rejected_without_calling_upstream() -> None:
|
||||
client = RecordingSearchClient()
|
||||
service = RetrievalService(
|
||||
search_client=client,
|
||||
allowed_kb_ids=frozenset({ALLOWED_KB_ID}),
|
||||
)
|
||||
|
||||
with pytest.raises(InvalidRequestError):
|
||||
await service.retrieve(request_for(DENIED_KB_ID))
|
||||
|
||||
assert client.calls == []
|
||||
|
||||
|
||||
async def test_allowed_kb_calls_upstream_once_with_normalized_values() -> None:
|
||||
client = RecordingSearchClient()
|
||||
service = RetrievalService(
|
||||
search_client=client,
|
||||
allowed_kb_ids=frozenset({ALLOWED_KB_ID}),
|
||||
)
|
||||
|
||||
response = await service.retrieve(request_for())
|
||||
|
||||
assert response == {"records": []}
|
||||
assert client.calls == [("test query", ALLOWED_KB_ID)]
|
||||
|
||||
|
||||
async def test_matching_chunk_is_mapped_to_dify_record() -> None:
|
||||
chunk_id = "c7f61f89-19ce-45b1-ac60-dbeed5e2a491"
|
||||
knowledge_id = "6f77a258-27ff-4278-a667-8fe242ff8e10"
|
||||
client = RecordingSearchClient(
|
||||
[
|
||||
{
|
||||
"id": chunk_id,
|
||||
"content": "safe chunk content",
|
||||
"score": 0.82,
|
||||
"knowledge_base_id": str(ALLOWED_KB_ID),
|
||||
"knowledge_id": knowledge_id,
|
||||
"knowledge_title": "Operation Manual",
|
||||
"knowledge_filename": "manual.pdf",
|
||||
"chunk_index": 4,
|
||||
"chunk_type": "text",
|
||||
"image_info": "",
|
||||
}
|
||||
]
|
||||
)
|
||||
service = RetrievalService(
|
||||
search_client=client,
|
||||
allowed_kb_ids=frozenset({ALLOWED_KB_ID}),
|
||||
)
|
||||
|
||||
response = await service.retrieve(request_for())
|
||||
|
||||
assert response == {
|
||||
"records": [
|
||||
{
|
||||
"content": "safe chunk content",
|
||||
"score": 0.82,
|
||||
"title": "Operation Manual",
|
||||
"metadata": {
|
||||
"knowledge_base_id": str(ALLOWED_KB_ID),
|
||||
"knowledge_id": knowledge_id,
|
||||
"chunk_id": chunk_id,
|
||||
"chunk_index": 4,
|
||||
"chunk_type": "text",
|
||||
},
|
||||
}
|
||||
]
|
||||
}
|
||||
|
||||
|
||||
async def test_cross_kb_chunk_is_dropped_after_upstream_returns() -> None:
|
||||
client = RecordingSearchClient(
|
||||
[
|
||||
{
|
||||
"id": "c7f61f89-19ce-45b1-ac60-dbeed5e2a491",
|
||||
"content": "must not escape",
|
||||
"score": 0.99,
|
||||
"knowledge_base_id": str(DENIED_KB_ID),
|
||||
"knowledge_id": "6f77a258-27ff-4278-a667-8fe242ff8e10",
|
||||
"knowledge_title": "Other KB",
|
||||
"knowledge_filename": "other.pdf",
|
||||
"chunk_index": 0,
|
||||
"chunk_type": "text",
|
||||
"image_info": "",
|
||||
}
|
||||
]
|
||||
)
|
||||
service = RetrievalService(
|
||||
search_client=client,
|
||||
allowed_kb_ids=frozenset({ALLOWED_KB_ID, DENIED_KB_ID}),
|
||||
)
|
||||
|
||||
response = await service.retrieve(request_for(ALLOWED_KB_ID))
|
||||
|
||||
assert response == {"records": []}
|
||||
|
||||
|
||||
async def test_score_threshold_filters_without_resorting() -> None:
|
||||
base = {
|
||||
"knowledge_base_id": str(ALLOWED_KB_ID),
|
||||
"knowledge_id": "6f77a258-27ff-4278-a667-8fe242ff8e10",
|
||||
"knowledge_title": "Manual",
|
||||
"knowledge_filename": "manual.pdf",
|
||||
"chunk_type": "text",
|
||||
"image_info": "",
|
||||
}
|
||||
client = RecordingSearchClient(
|
||||
[
|
||||
{
|
||||
**base,
|
||||
"id": "c7f61f89-19ce-45b1-ac60-dbeed5e2a491",
|
||||
"content": "below",
|
||||
"score": 0.49,
|
||||
"chunk_index": 0,
|
||||
},
|
||||
{
|
||||
**base,
|
||||
"id": "09ab721f-7d05-45de-ae0f-dac303276f6d",
|
||||
"content": "at threshold",
|
||||
"score": 0.5,
|
||||
"chunk_index": 1,
|
||||
},
|
||||
]
|
||||
)
|
||||
service = RetrievalService(
|
||||
search_client=client,
|
||||
allowed_kb_ids=frozenset({ALLOWED_KB_ID}),
|
||||
)
|
||||
|
||||
response = await service.retrieve(request_for())
|
||||
|
||||
assert [(record["content"], record["score"]) for record in response["records"]] == [
|
||||
("at threshold", 0.5)
|
||||
]
|
||||
|
||||
|
||||
async def test_requested_top_k_is_clamped_to_service_maximum() -> None:
|
||||
raw_chunks = [
|
||||
{
|
||||
"id": str(UUID(int=index + 1)),
|
||||
"content": f"chunk-{index}",
|
||||
"score": 0.9,
|
||||
"knowledge_base_id": str(ALLOWED_KB_ID),
|
||||
"knowledge_id": "6f77a258-27ff-4278-a667-8fe242ff8e10",
|
||||
"knowledge_title": "Manual",
|
||||
"knowledge_filename": "manual.pdf",
|
||||
"chunk_index": index,
|
||||
"chunk_type": "text",
|
||||
"image_info": "",
|
||||
}
|
||||
for index in range(6)
|
||||
]
|
||||
service = RetrievalService(
|
||||
search_client=RecordingSearchClient(raw_chunks),
|
||||
allowed_kb_ids=frozenset({ALLOWED_KB_ID}),
|
||||
)
|
||||
|
||||
response = await service.retrieve(request_for(top_k=100000))
|
||||
|
||||
assert [record["content"] for record in response["records"]] == [
|
||||
"chunk-0",
|
||||
"chunk-1",
|
||||
"chunk-2",
|
||||
"chunk-3",
|
||||
"chunk-4",
|
||||
]
|
||||
|
||||
|
||||
async def test_single_chunk_content_is_hard_limited() -> None:
|
||||
client = RecordingSearchClient(
|
||||
[
|
||||
{
|
||||
"id": "c7f61f89-19ce-45b1-ac60-dbeed5e2a491",
|
||||
"content": "文" * 5000,
|
||||
"score": 0.9,
|
||||
"knowledge_base_id": str(ALLOWED_KB_ID),
|
||||
"knowledge_id": "6f77a258-27ff-4278-a667-8fe242ff8e10",
|
||||
"knowledge_title": "Manual",
|
||||
"knowledge_filename": "manual.pdf",
|
||||
"chunk_index": 0,
|
||||
"chunk_type": "text",
|
||||
"image_info": "",
|
||||
}
|
||||
]
|
||||
)
|
||||
service = RetrievalService(
|
||||
search_client=client,
|
||||
allowed_kb_ids=frozenset({ALLOWED_KB_ID}),
|
||||
)
|
||||
|
||||
response = await service.retrieve(request_for())
|
||||
content = response["records"][0]["content"]
|
||||
|
||||
assert isinstance(content, str)
|
||||
assert len(content) <= 4000
|
||||
assert content.endswith(TRUNCATION_MARKER)
|
||||
|
||||
|
||||
async def test_total_returned_content_stops_at_hard_budget() -> None:
|
||||
raw_chunks = [
|
||||
{
|
||||
"id": str(UUID(int=index + 100)),
|
||||
"content": str(index) * 4000,
|
||||
"score": 0.9,
|
||||
"knowledge_base_id": str(ALLOWED_KB_ID),
|
||||
"knowledge_id": "6f77a258-27ff-4278-a667-8fe242ff8e10",
|
||||
"knowledge_title": "Manual",
|
||||
"knowledge_filename": "manual.pdf",
|
||||
"chunk_index": index,
|
||||
"chunk_type": "text",
|
||||
"image_info": "",
|
||||
}
|
||||
for index in range(4)
|
||||
]
|
||||
service = RetrievalService(
|
||||
search_client=RecordingSearchClient(raw_chunks),
|
||||
allowed_kb_ids=frozenset({ALLOWED_KB_ID}),
|
||||
)
|
||||
|
||||
response = await service.retrieve(request_for(top_k=5))
|
||||
returned_contents = [record["content"] for record in response["records"]]
|
||||
|
||||
assert len(returned_contents) == 3
|
||||
assert sum(len(content) for content in returned_contents if isinstance(content, str)) <= 12000
|
||||
|
||||
|
||||
async def test_length_budget_is_applied_after_content_processing() -> None:
|
||||
client = RecordingSearchClient(
|
||||
[
|
||||
{
|
||||
"id": "c7f61f89-19ce-45b1-ac60-dbeed5e2a491",
|
||||
"content": "x",
|
||||
"score": 0.9,
|
||||
"knowledge_base_id": str(ALLOWED_KB_ID),
|
||||
"knowledge_id": "6f77a258-27ff-4278-a667-8fe242ff8e10",
|
||||
"knowledge_title": "Manual",
|
||||
"knowledge_filename": "manual.pdf",
|
||||
"chunk_index": 0,
|
||||
"chunk_type": "text",
|
||||
"image_info": "",
|
||||
}
|
||||
]
|
||||
)
|
||||
limit = len(TRUNCATION_MARKER) + 5
|
||||
service = RetrievalService(
|
||||
search_client=client,
|
||||
allowed_kb_ids=frozenset({ALLOWED_KB_ID}),
|
||||
content_processor=ExpandingContentProcessor(),
|
||||
max_chunk_chars=limit,
|
||||
)
|
||||
|
||||
response = await service.retrieve(request_for())
|
||||
content = response["records"][0]["content"]
|
||||
|
||||
assert isinstance(content, str)
|
||||
assert content == f"xxxxx{TRUNCATION_MARKER}"
|
||||
assert len(content) == limit
|
||||
@@ -0,0 +1,158 @@
|
||||
from pathlib import Path
|
||||
from typing import Any
|
||||
from uuid import UUID
|
||||
|
||||
import pytest
|
||||
from pydantic import SecretStr, ValidationError
|
||||
|
||||
from knowledge_adapter.content_budget import TRUNCATION_MARKER
|
||||
from knowledge_adapter.settings import Settings
|
||||
|
||||
BASE_SETTINGS: dict[str, Any] = {
|
||||
"DIFY_KEY_HASH_CURRENT": "a" * 64,
|
||||
"DIFY_KEY_HASH_NEXT": "",
|
||||
"WEKNORA_BASE_URL": "http://weknora.internal:8080",
|
||||
"WEKNORA_ALLOWED_KB_IDS": (
|
||||
"3904b40e-278b-4273-a6fa-db6cbc975587,"
|
||||
"7fa6e8d2-05d8-4e74-b98c-d8591b680db9"
|
||||
),
|
||||
"WEKNORA_TENANT_ID": 10008,
|
||||
"WEKNORA_OSS_STORAGE_BACKEND_ID": "backend-test",
|
||||
"OSS_REGION": "cn-shenzhen",
|
||||
"OSS_BUCKET": "private-assets",
|
||||
"OSS_RAM_ROLE_NAME": "knowledge-adapter-role",
|
||||
"ASSET_PUBLIC_BASE_URL": "https://assets.example.com",
|
||||
}
|
||||
|
||||
|
||||
def test_settings_parse_allowlist_secrets_and_required_defaults() -> None:
|
||||
settings = Settings(**BASE_SETTINGS)
|
||||
|
||||
assert settings.dify_key_hash_current == "a" * 64
|
||||
assert settings.dify_key_hash_next is None
|
||||
assert settings.weknora_api_key_file == Path("/run/secrets/weknora_api_key")
|
||||
assert settings.weknora_allowed_kb_ids == frozenset(
|
||||
{
|
||||
UUID("3904b40e-278b-4273-a6fa-db6cbc975587"),
|
||||
UUID("7fa6e8d2-05d8-4e74-b98c-d8591b680db9"),
|
||||
}
|
||||
)
|
||||
assert settings.weknora_tenant_id == 10008
|
||||
assert settings.weknora_oss_storage_backend_id == "backend-test"
|
||||
assert settings.max_query_chars == 2000
|
||||
assert settings.max_top_k == 5
|
||||
assert settings.max_chunk_chars == 4000
|
||||
assert settings.max_total_chars == 12000
|
||||
assert settings.weknora_timeout_seconds == 15
|
||||
assert settings.asset_database_url_file == Path("/run/secrets/asset_database_url")
|
||||
assert settings.weknora_readonly_database_url_file == Path(
|
||||
"/run/secrets/weknora_readonly_database_url"
|
||||
)
|
||||
|
||||
|
||||
def test_settings_reject_malformed_current_key_hash() -> None:
|
||||
values = {**BASE_SETTINGS, "DIFY_KEY_HASH_CURRENT": "not-a-sha256"}
|
||||
|
||||
with pytest.raises(ValidationError):
|
||||
Settings(**values)
|
||||
|
||||
|
||||
def test_settings_uses_weknora_api_key_secret_file(tmp_path: Path) -> None:
|
||||
secret_file = tmp_path / "weknora-api-key"
|
||||
values = {
|
||||
key: value
|
||||
for key, value in BASE_SETTINGS.items()
|
||||
if key != "WEKNORA_API_KEY"
|
||||
}
|
||||
values["WEKNORA_API_KEY_FILE"] = secret_file
|
||||
|
||||
settings = Settings(**values)
|
||||
|
||||
assert settings.weknora_api_key_file == secret_file
|
||||
assert not hasattr(settings, "weknora_api_key")
|
||||
|
||||
|
||||
def test_settings_reads_weknora_api_key_at_runtime(tmp_path: Path) -> None:
|
||||
secret_file = tmp_path / "weknora-api-key"
|
||||
secret_file.write_text("weknora-test-secret\n", encoding="utf-8")
|
||||
values = {
|
||||
key: value
|
||||
for key, value in BASE_SETTINGS.items()
|
||||
if key != "WEKNORA_API_KEY"
|
||||
}
|
||||
values["WEKNORA_API_KEY_FILE"] = secret_file
|
||||
settings = Settings(**values)
|
||||
|
||||
api_key = settings.read_weknora_api_key()
|
||||
|
||||
assert isinstance(api_key, SecretStr)
|
||||
assert api_key.get_secret_value() == "weknora-test-secret"
|
||||
assert "weknora-test-secret" not in repr(settings)
|
||||
|
||||
|
||||
def test_static_ak_mode_reads_secret_files_without_ram_role(tmp_path: Path) -> None:
|
||||
access_key_id_file = tmp_path / "oss-access-key-id"
|
||||
access_key_secret_file = tmp_path / "oss-access-key-secret"
|
||||
access_key_id_file.write_text("test-access-key-id\n", encoding="utf-8")
|
||||
access_key_secret_file.write_text("test-access-key-secret\n", encoding="utf-8")
|
||||
values = {
|
||||
**BASE_SETTINGS,
|
||||
"OSS_CREDENTIAL_MODE": "static_ak",
|
||||
"OSS_RAM_ROLE_NAME": None,
|
||||
"OSS_ACCESS_KEY_ID_FILE": access_key_id_file,
|
||||
"OSS_ACCESS_KEY_SECRET_FILE": access_key_secret_file,
|
||||
}
|
||||
|
||||
settings = Settings(**values)
|
||||
|
||||
assert settings.oss_credential_mode == "static_ak"
|
||||
assert settings.oss_ram_role_name is None
|
||||
assert settings.read_oss_access_key_id().get_secret_value() == "test-access-key-id"
|
||||
assert settings.read_oss_access_key_secret().get_secret_value() == "test-access-key-secret"
|
||||
assert "test-access-key-id" not in repr(settings)
|
||||
assert "test-access-key-secret" not in repr(settings)
|
||||
|
||||
|
||||
@pytest.mark.parametrize("content", [None, " \n"])
|
||||
def test_settings_rejects_unavailable_weknora_api_key_secret(
|
||||
tmp_path: Path,
|
||||
content: str | None,
|
||||
) -> None:
|
||||
secret_file = tmp_path / "weknora-api-key"
|
||||
if content is not None:
|
||||
secret_file.write_text(content, encoding="utf-8")
|
||||
values = {
|
||||
key: value
|
||||
for key, value in BASE_SETTINGS.items()
|
||||
if key != "WEKNORA_API_KEY"
|
||||
}
|
||||
values["WEKNORA_API_KEY_FILE"] = secret_file
|
||||
settings = Settings(**values)
|
||||
|
||||
with pytest.raises(RuntimeError, match=r"^required secret unavailable$"):
|
||||
settings.read_weknora_api_key()
|
||||
|
||||
|
||||
def test_settings_reject_chunk_limit_smaller_than_truncation_marker() -> None:
|
||||
values = {**BASE_SETTINGS, "MAX_CHUNK_CHARS": len(TRUNCATION_MARKER) - 1}
|
||||
|
||||
with pytest.raises(ValidationError):
|
||||
Settings(**values)
|
||||
|
||||
|
||||
@pytest.mark.parametrize(
|
||||
("name", "value"),
|
||||
[
|
||||
("OSS_REGION", "https://attacker.example"),
|
||||
("OSS_REGION", "cn-shenzhen/internal"),
|
||||
("OSS_BUCKET", "Private_Assets"),
|
||||
("OSS_BUCKET", "https://attacker.example"),
|
||||
("OSS_RAM_ROLE_NAME", ""),
|
||||
("OSS_RAM_ROLE_NAME", "role/name"),
|
||||
],
|
||||
)
|
||||
def test_settings_reject_unsafe_oss_identifiers(name: str, value: str) -> None:
|
||||
values = {**BASE_SETTINGS, name: value}
|
||||
|
||||
with pytest.raises(ValidationError):
|
||||
Settings(**values)
|
||||
@@ -0,0 +1,113 @@
|
||||
from uuid import UUID
|
||||
|
||||
import httpx
|
||||
import pytest
|
||||
from pydantic import SecretStr
|
||||
|
||||
from knowledge_adapter.weknora_client import (
|
||||
WeKnoraBadResponseError,
|
||||
WeKnoraClient,
|
||||
WeKnoraUnavailableError,
|
||||
)
|
||||
|
||||
KB_ID = UUID("3904b40e-278b-4273-a6fa-db6cbc975587")
|
||||
WEKNORA_KEY = "test-weknora-key"
|
||||
|
||||
|
||||
async def test_search_uses_only_readonly_endpoint_and_expected_contract() -> None:
|
||||
requests: list[httpx.Request] = []
|
||||
|
||||
def handler(request: httpx.Request) -> httpx.Response:
|
||||
requests.append(request)
|
||||
return httpx.Response(200, json={"success": True, "data": []})
|
||||
|
||||
client = WeKnoraClient(
|
||||
base_url="http://weknora.internal:8080",
|
||||
api_key=SecretStr(WEKNORA_KEY),
|
||||
timeout_seconds=15,
|
||||
transport=httpx.MockTransport(handler),
|
||||
)
|
||||
async with client:
|
||||
results = await client.search(query="normalized query", knowledge_base_id=KB_ID)
|
||||
|
||||
assert results == []
|
||||
assert len(requests) == 1
|
||||
request = requests[0]
|
||||
assert request.method == "POST"
|
||||
assert request.url.path == "/api/v1/knowledge-search"
|
||||
assert request.headers["X-API-Key"] == WEKNORA_KEY
|
||||
assert request.headers.get("Authorization") is None
|
||||
assert request.read().decode() == (
|
||||
'{"query":"normalized query",'
|
||||
'"knowledge_base_ids":["3904b40e-278b-4273-a6fa-db6cbc975587"]}'
|
||||
)
|
||||
|
||||
|
||||
async def test_timeout_becomes_sanitized_unavailable_error() -> None:
|
||||
def handler(request: httpx.Request) -> httpx.Response:
|
||||
raise httpx.ReadTimeout("internal timeout details", request=request)
|
||||
|
||||
client = WeKnoraClient(
|
||||
base_url="http://weknora.internal:8080",
|
||||
api_key=SecretStr(WEKNORA_KEY),
|
||||
timeout_seconds=15,
|
||||
transport=httpx.MockTransport(handler),
|
||||
)
|
||||
|
||||
with pytest.raises(WeKnoraUnavailableError) as captured:
|
||||
async with client:
|
||||
await client.search(query="sensitive query", knowledge_base_id=KB_ID)
|
||||
|
||||
assert str(captured.value) == "WeKnora unavailable"
|
||||
|
||||
|
||||
async def test_500_becomes_sanitized_bad_response_error() -> None:
|
||||
def handler(_request: httpx.Request) -> httpx.Response:
|
||||
return httpx.Response(500, text="sensitive upstream failure")
|
||||
|
||||
client = WeKnoraClient(
|
||||
base_url="http://weknora.internal:8080",
|
||||
api_key=SecretStr(WEKNORA_KEY),
|
||||
timeout_seconds=15,
|
||||
transport=httpx.MockTransport(handler),
|
||||
)
|
||||
|
||||
with pytest.raises(WeKnoraBadResponseError) as captured:
|
||||
async with client:
|
||||
await client.search(query="sensitive query", knowledge_base_id=KB_ID)
|
||||
|
||||
assert str(captured.value) == "invalid WeKnora response"
|
||||
|
||||
|
||||
async def test_non_json_200_becomes_sanitized_bad_response_error() -> None:
|
||||
def handler(_request: httpx.Request) -> httpx.Response:
|
||||
return httpx.Response(200, text="not-json sensitive body")
|
||||
|
||||
client = WeKnoraClient(
|
||||
base_url="http://weknora.internal:8080",
|
||||
api_key=SecretStr(WEKNORA_KEY),
|
||||
timeout_seconds=15,
|
||||
transport=httpx.MockTransport(handler),
|
||||
)
|
||||
|
||||
with pytest.raises(WeKnoraBadResponseError) as captured:
|
||||
async with client:
|
||||
await client.search(query="sensitive query", knowledge_base_id=KB_ID)
|
||||
|
||||
assert str(captured.value) == "invalid WeKnora response"
|
||||
|
||||
|
||||
async def test_success_false_becomes_bad_response_error() -> None:
|
||||
def handler(_request: httpx.Request) -> httpx.Response:
|
||||
return httpx.Response(200, json={"success": False, "data": []})
|
||||
|
||||
client = WeKnoraClient(
|
||||
base_url="http://weknora.internal:8080",
|
||||
api_key=SecretStr(WEKNORA_KEY),
|
||||
timeout_seconds=15,
|
||||
transport=httpx.MockTransport(handler),
|
||||
)
|
||||
|
||||
with pytest.raises(WeKnoraBadResponseError):
|
||||
async with client:
|
||||
await client.search(query="query", knowledge_base_id=KB_ID)
|
||||
@@ -0,0 +1,31 @@
|
||||
from pathlib import Path
|
||||
|
||||
PROJECT_ROOT = Path(__file__).resolve().parents[1]
|
||||
GRANT_SQL = PROJECT_ROOT / "deploy" / "sql" / "weknora_readonly_grants.sql"
|
||||
|
||||
|
||||
def test_weknora_role_grants_only_required_resource_columns() -> None:
|
||||
assert GRANT_SQL.exists(), "WeKnora readonly grant SQL is missing"
|
||||
|
||||
sql = " ".join(GRANT_SQL.read_text(encoding="utf-8").lower().split())
|
||||
required_columns = (
|
||||
"handle, tenant_id, storage_backend_id, provider, physical_path, "
|
||||
"mime_type, state, deleted_at"
|
||||
)
|
||||
assert "grant usage on schema public" in sql
|
||||
assert f"grant select ({required_columns}) on table public.resources" in sql
|
||||
assert "grant select on table" not in sql
|
||||
assert "grant select on all tables" not in sql
|
||||
|
||||
for forbidden_operation in ("insert", "update", "delete", "truncate", "create", "alter"):
|
||||
assert f"grant {forbidden_operation}" not in sql
|
||||
for forbidden_table in (
|
||||
"users",
|
||||
"api_keys",
|
||||
"models",
|
||||
"knowledge_chunks",
|
||||
"knowledges",
|
||||
"knowledge_bases",
|
||||
"storage_backends",
|
||||
):
|
||||
assert f"public.{forbidden_table}" not in sql
|
||||
@@ -0,0 +1,237 @@
|
||||
from contextlib import AbstractAsyncContextManager
|
||||
from types import TracebackType
|
||||
from uuid import UUID
|
||||
|
||||
import pytest
|
||||
|
||||
from knowledge_adapter.weknora_resource_resolver import (
|
||||
ResolvedAsset,
|
||||
ResourceResolutionError,
|
||||
WeKnoraResourceResolver,
|
||||
)
|
||||
|
||||
HANDLE = "AbCdEfGhIjKlMnOpQrSt_1"
|
||||
BACKEND_ID = "550e8400-e29b-41d4-a716-446655440000"
|
||||
|
||||
|
||||
class FakeTransaction(AbstractAsyncContextManager[None]):
|
||||
def __init__(self) -> None:
|
||||
self.entered = False
|
||||
self.readonly: bool | None = None
|
||||
|
||||
async def __aenter__(self) -> None:
|
||||
self.entered = True
|
||||
|
||||
async def __aexit__(
|
||||
self,
|
||||
exc_type: type[BaseException] | None,
|
||||
exc_value: BaseException | None,
|
||||
traceback: TracebackType | None,
|
||||
) -> None:
|
||||
return None
|
||||
|
||||
|
||||
class FakeConnection:
|
||||
def __init__(self, rows: list[dict[str, object]]) -> None:
|
||||
self.rows = rows
|
||||
self.transaction_context = FakeTransaction()
|
||||
self.query = ""
|
||||
self.args: tuple[object, ...] = ()
|
||||
|
||||
def transaction(self, *, readonly: bool) -> FakeTransaction:
|
||||
self.transaction_context.readonly = readonly
|
||||
return self.transaction_context
|
||||
|
||||
async def fetch(self, query: str, *args: object) -> list[dict[str, object]]:
|
||||
self.query = query
|
||||
self.args = args
|
||||
return self.rows
|
||||
|
||||
|
||||
class AcquireContext(AbstractAsyncContextManager[FakeConnection]):
|
||||
def __init__(self, connection: FakeConnection) -> None:
|
||||
self.connection = connection
|
||||
|
||||
async def __aenter__(self) -> FakeConnection:
|
||||
return self.connection
|
||||
|
||||
async def __aexit__(
|
||||
self,
|
||||
exc_type: type[BaseException] | None,
|
||||
exc_value: BaseException | None,
|
||||
traceback: TracebackType | None,
|
||||
) -> None:
|
||||
return None
|
||||
|
||||
|
||||
class FakePool:
|
||||
def __init__(self, connection: FakeConnection) -> None:
|
||||
self.connection = connection
|
||||
self.acquire_count = 0
|
||||
|
||||
def acquire(self) -> AcquireContext:
|
||||
self.acquire_count += 1
|
||||
return AcquireContext(self.connection)
|
||||
|
||||
|
||||
class FailingConnection(FakeConnection):
|
||||
async def fetch(self, query: str, *args: object) -> list[dict[str, object]]:
|
||||
raise RuntimeError(
|
||||
"postgresql://readonly:secret@db.internal resources physical_path=private/object"
|
||||
)
|
||||
|
||||
|
||||
async def test_resolver_uses_minimal_parameterized_readonly_query() -> None:
|
||||
connection = FakeConnection(
|
||||
[
|
||||
{
|
||||
"tenant_id": 10008,
|
||||
"storage_backend_id": "backend-test",
|
||||
"provider": "oss",
|
||||
"physical_path": (
|
||||
"storage://backend-test/"
|
||||
"oss://private-assets/weknora/10008/assets/image.png"
|
||||
),
|
||||
"mime_type": "image/png",
|
||||
}
|
||||
]
|
||||
)
|
||||
resolver = WeKnoraResourceResolver(
|
||||
pool=FakePool(connection),
|
||||
tenant_id=10008,
|
||||
storage_backend_id="backend-test",
|
||||
bucket="private-assets",
|
||||
)
|
||||
|
||||
resolved = await resolver.resolve(f"resource://{HANDLE}")
|
||||
|
||||
assert resolved == ResolvedAsset(
|
||||
object_key="weknora/10008/assets/image.png",
|
||||
content_type="image/png",
|
||||
)
|
||||
assert connection.transaction_context.entered is True
|
||||
assert connection.transaction_context.readonly is True
|
||||
assert connection.args == (HANDLE, 10008, "backend-test")
|
||||
normalized_query = " ".join(connection.query.split()).lower()
|
||||
assert normalized_query.startswith(
|
||||
"select tenant_id, storage_backend_id, provider, physical_path, mime_type from resources"
|
||||
)
|
||||
assert "handle = $1" in normalized_query
|
||||
assert "tenant_id = $2" in normalized_query
|
||||
assert "storage_backend_id = $3" in normalized_query
|
||||
assert "state = 'active'" in normalized_query
|
||||
assert "deleted_at is null" in normalized_query
|
||||
for forbidden_column in ("content", "credentials", "api_key", "secret", "original_name"):
|
||||
assert forbidden_column not in normalized_query
|
||||
|
||||
|
||||
async def test_resolver_accepts_asyncpg_uuid_storage_backend_id() -> None:
|
||||
connection = FakeConnection(
|
||||
[
|
||||
{
|
||||
"tenant_id": 10008,
|
||||
"storage_backend_id": UUID(BACKEND_ID),
|
||||
"provider": "oss",
|
||||
"physical_path": (
|
||||
f"storage://{BACKEND_ID}/"
|
||||
"oss://private-assets/weknora/10008/assets/image.png"
|
||||
),
|
||||
"mime_type": "image/png",
|
||||
}
|
||||
]
|
||||
)
|
||||
resolver = WeKnoraResourceResolver(
|
||||
pool=FakePool(connection),
|
||||
tenant_id=10008,
|
||||
storage_backend_id=BACKEND_ID,
|
||||
bucket="private-assets",
|
||||
)
|
||||
|
||||
resolved = await resolver.resolve(f"resource://{HANDLE}")
|
||||
|
||||
assert resolved.object_key == "weknora/10008/assets/image.png"
|
||||
|
||||
|
||||
@pytest.mark.parametrize("row_count", [0, 2])
|
||||
async def test_resolver_requires_exactly_one_resource_row(row_count: int) -> None:
|
||||
row = {
|
||||
"tenant_id": 10008,
|
||||
"storage_backend_id": "backend-test",
|
||||
"provider": "oss",
|
||||
"physical_path": (
|
||||
"storage://backend-test/"
|
||||
"oss://private-assets/weknora/10008/assets/image.png"
|
||||
),
|
||||
"mime_type": "image/png",
|
||||
}
|
||||
resolver = WeKnoraResourceResolver(
|
||||
pool=FakePool(FakeConnection([row] * row_count)),
|
||||
tenant_id=10008,
|
||||
storage_backend_id="backend-test",
|
||||
bucket="private-assets",
|
||||
)
|
||||
|
||||
with pytest.raises(ResourceResolutionError, match=r"^resource unavailable$"):
|
||||
await resolver.resolve(f"resource://{HANDLE}")
|
||||
|
||||
|
||||
@pytest.mark.parametrize(
|
||||
"overrides",
|
||||
[
|
||||
{"tenant_id": 99999},
|
||||
{"storage_backend_id": "other-backend"},
|
||||
{"provider": "cos"},
|
||||
],
|
||||
)
|
||||
async def test_resolver_rechecks_row_ownership(overrides: dict[str, object]) -> None:
|
||||
row = {
|
||||
"tenant_id": 10008,
|
||||
"storage_backend_id": "backend-test",
|
||||
"provider": "oss",
|
||||
"physical_path": (
|
||||
"storage://backend-test/"
|
||||
"oss://private-assets/weknora/10008/assets/image.png"
|
||||
),
|
||||
"mime_type": "image/png",
|
||||
**overrides,
|
||||
}
|
||||
resolver = WeKnoraResourceResolver(
|
||||
pool=FakePool(FakeConnection([row])),
|
||||
tenant_id=10008,
|
||||
storage_backend_id="backend-test",
|
||||
bucket="private-assets",
|
||||
)
|
||||
|
||||
with pytest.raises(ResourceResolutionError, match=r"^resource unavailable$"):
|
||||
await resolver.resolve(f"resource://{HANDLE}")
|
||||
|
||||
|
||||
async def test_resolver_maps_database_error_to_safe_fixed_error() -> None:
|
||||
resolver = WeKnoraResourceResolver(
|
||||
pool=FakePool(FailingConnection([])),
|
||||
tenant_id=10008,
|
||||
storage_backend_id="backend-test",
|
||||
bucket="private-assets",
|
||||
)
|
||||
|
||||
with pytest.raises(ResourceResolutionError) as captured:
|
||||
await resolver.resolve(f"resource://{HANDLE}")
|
||||
|
||||
assert str(captured.value) == "resource unavailable"
|
||||
assert "postgresql" not in str(captured.value)
|
||||
assert "physical_path" not in str(captured.value)
|
||||
|
||||
|
||||
async def test_invalid_resource_reference_is_rejected_before_database_access() -> None:
|
||||
pool = FakePool(FakeConnection([]))
|
||||
resolver = WeKnoraResourceResolver(
|
||||
pool=pool,
|
||||
tenant_id=10008,
|
||||
storage_backend_id="backend-test",
|
||||
bucket="private-assets",
|
||||
)
|
||||
|
||||
with pytest.raises(ResourceResolutionError, match=r"^resource unavailable$"):
|
||||
await resolver.resolve("https://attacker.example/image.png")
|
||||
|
||||
assert pool.acquire_count == 0
|
||||
Reference in New Issue
Block a user