feat(asset): 清理被截断的结尾图片引用,修复整单 502

仓库首次入库(此前仅存在于本地工作区与测试服构建产物中,未上传)。

改动(src/knowledge_adapter/asset_content_processor.py):
- 新增 _TRUNCATED_TRAILING_MARKDOWN_RESOURCE_IMAGE 规则,清除 chunk 末尾被截断的
  ![](resource://xxxx 残片(WeKnora 分块在图片引用中间截断时产生,旧逻辑无法匹配完整引用,
  残留 resource:// 触发 ContentProcessingError,导致整单 502)
- 回归测试 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:
姚章浩
2026-09-16 10:01:27 +08:00
commit 693cd952cd
64 changed files with 7869 additions and 0 deletions
+314
View File
@@ -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 ![diagram]({SOURCE_REF}) after")
processed = await processor.process(chunk)
assert processed == (
f"Before ![diagram](https://assets.example.com/i/{ASSET_ID}) 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"![diagram]({SOURCE_REF})")
)
assert processed == f"![diagram](https://assets.example.com/i/{ASSET_ID})"
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"![first]({SOURCE_REF}) and ![second]({SOURCE_REF})"
)
processed = await processor.process(chunk)
public_url = f"https://assets.example.com/i/{ASSET_ID}"
assert processed == f"![first]({public_url}) and ![second]({public_url})"
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![知识图片]({public_url})"
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"![diagram]({SOURCE_REF})"))
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![diagram](resource://4j9P")
)
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))
+126
View File
@@ -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 == []
+209
View File
@@ -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
+127
View File
@@ -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]
+91
View File
@@ -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
+34
View File
@@ -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 "
"![image](https://assets.example.com/i/550e8400-e29b-41d4-a716-446655440000)"
" trailing text"
)
limit = len(TRUNCATION_MARKER) + len("prefix ![image](https://assets.")
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
+218
View File
@@ -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
+22
View File
@@ -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]
+632
View File
@@ -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"![diagram]({source_ref})",
"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"] == (
"![diagram](https://assets.example.com/i/"
"c7f61f89-19ce-45b1-ac60-dbeed5e2a491)"
)
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
+27
View File
@@ -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
+41
View File
@@ -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;"
+258
View File
@@ -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]
+150
View File
@@ -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)
+110
View File
@@ -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",
)
+269
View File
@@ -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
+302
View File
@@ -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
+158
View File
@@ -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)
+113
View File
@@ -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)
+31
View File
@@ -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
+237
View File
@@ -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