Build Agentic workflows, RAG pipelines, with rich AI model and tool support on one collaborative workspace. Deploy on cloud, VPC, or self-hosted, so teams move from prototype to production without rebuilding the stack.
Python agentagentic-aiagentic-frameworkagentic-workflowaiautomationclaudedeepseekgenaigptllmlow-codemcpnextjsno-codeopenaipythonskillsworkflow
refactor(api): isolate trial file upload admission and actors (#42625)
非法操作206cf8fb9466
diff --git a/api/controllers/console/explore/trial.py b/api/controllers/console/explore/trial.pyindex 26bc46cda1c..cb0f29a2910 100644--- a/api/controllers/console/explore/trial.py+++ b/api/controllers/console/explore/trial.py@@ -19,6 +19,7 @@ from controllers.common.fields import (from controllers.common.fields import Parameters as ParametersResponsefrom controllers.common.fields import Site as SiteResponsefrom controllers.common.schema import (+ JsonResponseWithStatus,query_params_from_model,register_response_schema_models,register_schema_models,@@ -47,7 +48,7 @@ from controllers.console.explore.error import ()from controllers.console.explore.trial_app_admission import get_trial_appfrom controllers.console.explore.wraps import TrialAppResource-from controllers.console.files import FILE_UPLOAD_PARAMS, upload_file_from_request+from controllers.console.files import FILE_UPLOAD_PARAMS, upload_file_from_request_contextfrom controllers.console.flask_admission import console_account_admissionfrom controllers.console.remote_files import RemoteFileUploadPayload, upload_remote_filefrom controllers.console.wraps import cloud_edition_billing_resource_check, model_validate, with_current_user@@ -72,8 +73,9 @@ from graphon.variables import SecretVariable, VariableBasefrom libs import helperfrom libs.helper import dump_response, to_timestamp, uuid_valuefrom machinery.context import RequestContext-from models import Account, App+from models import Accountfrom models.account import TenantStatus+from models.enums import CreatorUserRolefrom models.model import AppMode, Sitefrom models.workflow import Workflowfrom services.account_errors import AccountNotFoundError@@ -96,6 +98,7 @@ from services.errors.message import (MessageNotExistsError,SuggestedQuestionsAfterAnswerDisabledError,)+from services.file_service import FileUploadActorfrom services.message_service import MessageServicefrom services.trial_app_access_service import TrialAppReffrom services.trial_app_generation_service import (@@ -460,32 +463,36 @@ register_response_schema_models(simple_account_model = console_ns.models[TrialSimpleAccount.__name__]-class TrialAppFileUploadApi(TrialAppResource):- @cloud_edition_billing_resource_check("documents")+class TrialAppFileUploadApi(Resource):@console_ns.doc(consumes=["multipart/form-data"], params=FILE_UPLOAD_PARAMS)@console_ns.response(201, "File uploaded successfully", console_ns.models[FileResponse.__name__])- @with_current_user- def post(self, current_user: Account, app_model: App):+ @console_account_admission()+ @get_trial_app+ @cloud_edition_billing_resource_check("documents")+ def post(self, request_context: RequestContext, trial_app: TrialAppRef) -> JsonResponseWithStatus:"""Upload a file into the tenant that owns the trial app."""- upload_file = upload_file_from_request(- current_user=current_user,- resource_tenant_id=app_model.tenant_id,+ upload_file = upload_file_from_request_context(+ request_context=request_context,+ resource_tenant_id=trial_app.tenant_id,)return dump_response(FileResponse, upload_file), 201-class TrialAppRemoteFileUploadApi(TrialAppResource):- @cloud_edition_billing_resource_check("documents")+class TrialAppRemoteFileUploadApi(Resource):@console_ns.expect(console_ns.models[RemoteFileUploadPayload.__name__])@console_ns.response(201, "File uploaded successfully", console_ns.models[FileWithSignedUrl.__name__])- @with_current_user+ @console_account_admission()+ @get_trial_app+ @cloud_edition_billing_resource_check("documents")@model_validate(RemoteFileUploadPayload)- def post(self, payload: RemoteFileUploadPayload, current_user: Account, app_model: App):+ def post(+ self, payload: RemoteFileUploadPayload, request_context: RequestContext, trial_app: TrialAppRef+ ) -> JsonResponseWithStatus:"""Upload a remote file into the tenant that owns the trial app."""remote_file = upload_remote_file(url=payload.url,- current_user=current_user,- resource_tenant_id=app_model.tenant_id,+ current_user=FileUploadActor(id=request_context.account_id, creator_role=CreatorUserRole.ACCOUNT),+ resource_tenant_id=trial_app.tenant_id,)return dump_response(FileWithSignedUrl, remote_file), 201diff --git a/api/controllers/console/files.py b/api/controllers/console/files.pyindex 9ae0bafb6c7..7afc557aa6a 100644--- a/api/controllers/console/files.py+++ b/api/controllers/console/files.py@@ -1,8 +1,11 @@+from collections.abc import Generator+from contextlib import contextmanagerfrom typing import Literalfrom uuid import UUIDfrom flask import requestfrom flask_restx import Resource+from werkzeug.datastructures import FileStoragefrom werkzeug.exceptions import Forbiddenimport services@@ -29,10 +32,12 @@ from controllers.console.wraps import (from extensions.ext_application_services import application_servicesfrom fields.file_fields import FileResponse, UploadConfigfrom libs.helper import dump_response-from libs.login import login_required+from libs.login import current_account_with_tenant, login_requiredfrom machinery.context import RequestContextfrom models import Account, UploadFile+from models.enums import CreatorUserRolefrom services.feature_service import FeatureService+from services.file_service import FileUploadActor, FileUploadResultregister_response_schema_models(console_ns,@@ -61,8 +66,8 @@ FILE_UPLOAD_PARAMS = {}-def upload_file_from_request(*, current_user: Account, resource_tenant_id: str | None = None) -> UploadFile:- """Validate the multipart request and persist the file under the requested resource tenant."""+def _parse_file_upload() -> tuple[FileStorage, str, Literal["datasets"] | None]:+ """Validate multipart shape before checking source-specific permissions."""source_str = request.args.get("source") or request.form.get("source")source: Literal["datasets"] | None = "datasets" if source_str == "datasets" else None@@ -75,21 +80,37 @@ def upload_file_from_request(*, current_user: Account, resource_tenant_id: str |if not file.filename:raise FilenameNotExistsError()++ return file, file.filename, source+++@contextmanager+def _file_upload_errors() -> Generator[None, None, None]:+ try:+ yield+ except services.errors.file.FileTooLargeError as file_too_large_error:+ raise FileTooLargeError(file_too_large_error.description or "File size exceeded.") from file_too_large_error+ except services.errors.file.UnsupportedFileTypeError as unsupported_file_type_error:+ raise UnsupportedFileTypeError() from unsupported_file_type_error+ except services.errors.file.BlockedFileExtensionError as blocked_extension_error:+ raise BlockedFileExtensionError(blocked_extension_error.description) from blocked_extension_error+++def upload_file_from_request(*, current_user: Account, resource_tenant_id: str | None = None) -> UploadFile:+ """Validate the multipart request and persist the file under the requested resource tenant."""+ file, filename, source = _parse_file_upload()if source == "datasets" and not current_user.is_dataset_editor:raise Forbidden()- if source not in ("datasets", None):- source = None-default_file_size_limit = (FeatureService.get_knowledge_file_size_limit(resource_tenant_id or current_user.current_tenant_id)if source == "datasets"else None)- try:+ with _file_upload_errors():return application_services().files.upload_file(- filename=file.filename,+ filename=filename,content=file.stream.read(),mimetype=file.mimetype,user=current_user,@@ -97,12 +118,28 @@ def upload_file_from_request(*, current_user: Account, resource_tenant_id: str |source=source,default_file_size_limit=default_file_size_limit,)- except services.errors.file.FileTooLargeError as file_too_large_error:- raise FileTooLargeError(file_too_large_error.description) from file_too_large_error- except services.errors.file.UnsupportedFileTypeError as unsupported_file_type_error:- raise UnsupportedFileTypeError() from unsupported_file_type_error- except services.errors.file.BlockedFileExtensionError as blocked_extension_error:- raise BlockedFileExtensionError(blocked_extension_error.description) from blocked_extension_error+++def upload_file_from_request_context(*, request_context: RequestContext, resource_tenant_id: str) -> FileUploadResult:+ """Admit a Console upload and pass only its creator and resource owner to storage."""+ file, filename, source = _parse_file_upload()+ if source == "datasets" and not current_account_with_tenant().account.is_dataset_editor:+ raise Forbidden()++ default_file_size_limit = (+ FeatureService.get_knowledge_file_size_limit(resource_tenant_id) if source == "datasets" else None+ )+ actor = FileUploadActor(id=request_context.account_id, creator_role=CreatorUserRole.ACCOUNT)+ with _file_upload_errors():+ return application_services().files.upload_file_for_actor(+ actor=actor,+ resource_tenant_id=resource_tenant_id,+ filename=filename,+ content=file.stream.read(),+ mimetype=file.mimetype,+ source=source,+ default_file_size_limit=default_file_size_limit,+ )@console_ns.route("/files/upload")diff --git a/api/controllers/console/remote_files.py b/api/controllers/console/remote_files.pyindex e7e4eef2f53..f3b058cd10c 100644--- a/api/controllers/console/remote_files.py+++ b/api/controllers/console/remote_files.py@@ -1,3 +1,5 @@+from typing import overload+from flask import requestfrom flask_restx import Resourcefrom pydantic import BaseModel, Field@@ -25,6 +27,7 @@ from libs.helper import dump_responsefrom libs.login import login_requiredfrom machinery.context import RequestContextfrom models import Account+from services.file_service import FileUploadActorfrom services.remote_file_service import (RemoteFileAccessDeniedError as RemoteFileAccessDeniedServiceError,)@@ -84,13 +87,37 @@ class GetRemoteFileInfo(Resource):)+@overloaddef upload_remote_file(*,url: str,current_user: Account,resource_tenant_id: str | None = None,+) -> RemoteFileUploadResult: ...+++@overload+def upload_remote_file(+ *,+ url: str,+ current_user: FileUploadActor,+ resource_tenant_id: str,+) -> RemoteFileUploadResult: ...+++def upload_remote_file(+ *,+ url: str,+ current_user: Account | FileUploadActor,+ resource_tenant_id: str | None = None,) -> RemoteFileUploadResult:- """Fetch a remote file and persist it under the requested tenant."""+ """Fetch a remote file and persist it under the requested tenant.++ For Account, resource_tenant_id=None (including when omitted) uses the+ current workspace; an explicit value takes precedence. FileUploadActor+ carries no tenant, so resource_tenant_id must be provided explicitly.+ RemoteFileService enforces this before fetching the remote file.+ """try:return application_services().remote_files.upload_from_url(url=url,diff --git a/api/services/file_service.py b/api/services/file_service.pyindex e06069c8cc2..eaae6065320 100644--- a/api/services/file_service.py+++ b/api/services/file_service.py@@ -5,6 +5,8 @@ import posixpathimport uuidfrom collections.abc import Generator, Sequence # Changed Iterator to Generatorfrom contextlib import contextmanager, suppress+from dataclasses import dataclass+from datetime import datetimefrom tempfile import NamedTemporaryFilefrom typing import Literalfrom zipfile import ZIP_DEFLATED, ZipFile@@ -36,6 +38,27 @@ from .errors.file import BlockedFileExtensionError, FileNotExistsError, FileTooLPREVIEW_WORDS_LIMIT = 3000+@dataclass(frozen=True, slots=True)+class FileUploadActor:+ """Creator identity, independent of the tenant receiving the upload."""++ id: str+ creator_role: CreatorUserRole+++@dataclass(frozen=True, slots=True)+class FileUploadResult:+ id: str+ name: str+ size: int+ extension: str+ mime_type: str+ created_by: str+ created_at: datetime+ tenant_id: str+ source_url: str++class FileService:_session_maker: sessionmaker[Session]@@ -54,12 +77,26 @@ class FileService:filename: str,content: bytes,mimetype: str,- user: Account | EndUser,+ user: Account | EndUser | FileUploadActor,tenant_id: str | None = None,source: Literal["datasets"] | None = None,source_url: str = "",default_file_size_limit: int | None = None,) -> UploadFile:+ """Persist a file with the given creator and resource tenant.++ For Account or EndUser, tenant_id=None (including when omitted) uses+ the account's current workspace or the end user's tenant. An explicit+ tenant_id takes precedence. FileUploadActor carries no tenant, so it+ requires an explicit tenant_id.++ default_file_size_limit is the non-media limit in MiB; None uses+ dify_config.UPLOAD_FILE_SIZE_LIMIT, and 0 permits only empty files.+ Images, video and audio always use their dedicated configured limits.+ """+ if isinstance(user, FileUploadActor) and tenant_id is None:+ raise TypeError("tenant_id is required when uploading with FileUploadActor")+# get file extensionextension = os.path.splitext(filename)[1].lstrip(".").lower()@@ -92,7 +129,12 @@ class FileService:# generate file keyfile_uuid = str(uuid.uuid4())- resource_tenant_id = tenant_id if tenant_id is not None else extract_tenant_id(user)+ if isinstance(user, FileUploadActor):+ resource_tenant_id = tenant_id+ creator_role = user.creator_role+ else:+ resource_tenant_id = tenant_id if tenant_id is not None else extract_tenant_id(user)+ creator_role = CreatorUserRole.ACCOUNT if isinstance(user, Account) else CreatorUserRole.END_USERfile_key = "upload_files/" + (resource_tenant_id or "") + "/" + file_uuid + "." + extension@@ -108,7 +150,7 @@ class FileService:size=file_size,extension=extension,mime_type=mimetype,- created_by_role=(CreatorUserRole.ACCOUNT if isinstance(user, Account) else CreatorUserRole.END_USER),+ created_by_role=creator_role,created_by=user.id,created_at=naive_utc_now(),used=False,@@ -125,6 +167,46 @@ class FileService:return upload_file+ def upload_file_for_actor(+ self,+ *,+ actor: FileUploadActor,+ resource_tenant_id: str,+ filename: str,+ content: bytes,+ mimetype: str,+ source: Literal["datasets"] | None = None,+ source_url: str = "",+ default_file_size_limit: int | None = None,+ ) -> FileUploadResult:+ """Upload into the explicitly admitted tenant and return detached values.++ default_file_size_limit overrides the non-media limit in MiB, including+ 0 for empty files only. None uses dify_config.UPLOAD_FILE_SIZE_LIMIT.+ Images, video and audio retain their dedicated configured limits.+ """+ upload_file = self.upload_file(+ filename=filename,+ content=content,+ mimetype=mimetype,+ user=actor,+ tenant_id=resource_tenant_id,+ source=source,+ source_url=source_url,+ default_file_size_limit=default_file_size_limit,+ )+ return FileUploadResult(+ id=upload_file.id,+ name=upload_file.name,+ size=upload_file.size,+ extension=upload_file.extension,+ mime_type=upload_file.mime_type,+ created_by=upload_file.created_by,+ created_at=upload_file.created_at,+ tenant_id=upload_file.tenant_id,+ source_url=upload_file.source_url,+ )+@staticmethoddef is_file_size_within_limit(*,@@ -143,7 +225,13 @@ class FileService:extension: str,default_file_size_limit: int | None = None,) -> int:- """Return the size an extension is allowed, in bytes."""+ """Return the size an extension is allowed, in bytes.++ default_file_size_limit is a non-media override in MiB. None uses+ dify_config.UPLOAD_FILE_SIZE_LIMIT; 0 allows only empty files.+ Images, video and audio use their dedicated limits regardless of this+ override.+ """if extension in IMAGE_EXTENSIONS:file_size_limit = dify_config.UPLOAD_IMAGE_FILE_SIZE_LIMITdiff --git a/api/services/remote_file_service.py b/api/services/remote_file_service.pyindex 1ccb63ebb9a..2d940abfd86 100644--- a/api/services/remote_file_service.py+++ b/api/services/remote_file_service.py@@ -13,7 +13,7 @@ from graphon.file import helpers as file_helpersfrom models import Accountfrom models.model import EndUserfrom services.errors.file import FileTooLargeError-from services.file_service import FileService+from services.file_service import FileService, FileUploadActor@dataclass(frozen=True, slots=True)@@ -87,9 +87,19 @@ class RemoteFileService:self,*,url: str,- user: Account | EndUser,+ user: Account | EndUser | FileUploadActor,tenant_id: str | None = None,) -> RemoteFileUploadResult:+ """Fetch and persist a remote file under the requested tenant.++ For Account or EndUser, tenant_id=None (including when omitted) uses+ the account's current workspace or the end user's tenant. An explicit+ tenant_id takes precedence. FileUploadActor requires an explicit+ tenant_id; it is checked before fetching the remote file.+ """+ if isinstance(user, FileUploadActor) and tenant_id is None:+ raise TypeError("tenant_id is required when uploading with FileUploadActor")+response = self._fetch_for_upload(url=url)try:file_info = guess_file_info_from_response(response)diff --git a/api/tests/unit_tests/controllers/console/explore/test_trial.py b/api/tests/unit_tests/controllers/console/explore/test_trial.pyindex 9cdd3012c09..75c55fe1f57 100644--- a/api/tests/unit_tests/controllers/console/explore/test_trial.py+++ b/api/tests/unit_tests/controllers/console/explore/test_trial.py@@ -36,13 +36,13 @@ from graphon.variables import SecretVariable, StringVariablefrom models import Account, Tenantfrom models.account import TenantStatusfrom models.dataset import Dataset-from models.model import App, AppMode, Site, UploadFile+from models.model import App, AppMode, Sitefrom models.tools import WorkflowToolProviderfrom models.workflow import Workflowfrom services.app_ref_service import AppRef, MessageReffrom services.errors.audio import SpeechToTextDisabledServiceErrorfrom services.errors.conversation import ConversationNotExistsError-from tests.unit_tests.model_factories import make_app, make_upload_file+from tests.unit_tests.model_factories import make_appunwrap: Any = inspect_unwrap@@ -69,18 +69,6 @@ def _app(*, app_id: str, mode: AppMode, tenant_id: str = "tenant-1") -> App:return make_app(app_id=app_id, tenant_id=tenant_id, name="Trial App", mode=mode, icon_type=None, enable_api=False)-def _upload_file(*, file_id: str = "upload-file-id", tenant_id: str = "app-tenant-id") -> UploadFile:- return make_upload_file(- file_id=file_id,- tenant_id=tenant_id,- storage_type="opendal",- key="trial/file.txt",- name="file.txt",- size=1,- created_by="u1",- )--def _file_data() -> Any:file_data: Any = BytesIO(b"fake audio data")file_data.filename = "test.wav"@@ -190,50 +178,6 @@ def test_trial_app_detail_serializes_with_explicit_session(module.TrialAppDetailResponse.model_validate.assert_called_once_with(response_view, from_attributes=True)-class TestTrialAppFileUploadApi:- def test_upload_uses_trial_app_tenant(self, app: Flask, account: Account) -> None:- api = module.TrialAppFileUploadApi()- method = unwrap(api.post)- app_model = _app(app_id="app-1", mode=AppMode.CHAT, tenant_id="app-tenant-id")- upload_file = _upload_file()-- with (- app.test_request_context("/", method="POST"),- patch.object(module, "upload_file_from_request", return_value=upload_file) as upload,- patch.object(module, "dump_response", return_value={"id": "upload-file-id"}),- ):- response, status = method(api, account, app_model)-- assert status == 201- assert response == {"id": "upload-file-id"}- upload.assert_called_once_with(current_user=account, resource_tenant_id="app-tenant-id")---class TestTrialAppRemoteFileUploadApi:- def test_upload_uses_trial_app_tenant(self, app: Flask, account: Account) -> None:- api = module.TrialAppRemoteFileUploadApi()- method = unwrap(api.post)- app_model = _app(app_id="app-1", mode=AppMode.CHAT, tenant_id="app-tenant-id")- remote_file = MagicMock()- payload = module.RemoteFileUploadPayload(url="https://example.com/file.txt")-- with (- app.test_request_context("/", method="POST", json={"url": "https://example.com/file.txt"}),- patch.object(module, "upload_remote_file", return_value=remote_file) as upload,- patch.object(module, "dump_response", return_value={"id": "upload-file-id"}) as dump,- ):- response, status = method(api, payload, account, app_model)-- assert status == 201- assert response == {"id": "upload-file-id"}- upload.assert_called_once_with(- url="https://example.com/file.txt",- current_user=account,- resource_tenant_id="app-tenant-id",- )- dump.assert_called_once_with(module.FileWithSignedUrl, remote_file)--class TestTrialMessageSuggestedQuestionApi:def test_not_chat_app(self, app: Flask, account: Account) -> None:api = module.TrialMessageSuggestedQuestionApi()diff --git a/api/tests/unit_tests/controllers/console/explore/test_trial_file_upload.py b/api/tests/unit_tests/controllers/console/explore/test_trial_file_upload.pynew file mode 100644index 00000000000..8405a8cd85f--- /dev/null+++ b/api/tests/unit_tests/controllers/console/explore/test_trial_file_upload.py@@ -0,0 +1,559 @@+"""Trial uploads through HTTP, real file services, and SQLite admission/persistence."""++import hashlib+from collections.abc import Callable, Mapping+from dataclasses import dataclass, field+from datetime import datetime+from io import BytesIO+from typing import Literal+from urllib.parse import parse_qs, urlsplit+from uuid import UUID, uuid4++import httpx+import pytest+from flask import Flask, Request+from sqlalchemy import Connection, delete, event, select+from sqlalchemy.orm import Session, SessionTransaction, sessionmaker+from werkzeug.test import TestResponse++import controllers.console.explore.trial as trial_module+import controllers.console.explore.trial_app_admission as admission_module+import controllers.console.files as files_module+import controllers.console.remote_files as remote_module+import controllers.console.wraps as console_wraps+import libs.login as login_module+import services.file_service as file_module+from core.file import remote_fetcher+from core.tools.errors import ToolSSRFError+from enums import DeploymentEdition+from extensions.ext_login import DifyLoginManager, unauthorized_handler+from libs.external_api import ExternalApi+from models import Account, AccountTrialAppRecord, App, AppMode, Tenant, TrialApp, UploadFile+from models.account import TenantAccountRole+from models.enums import CreatorUserRole+from repositories.trial_app_repository import TrialAppRepository+from services.entities.feature_entities import FeatureModel+from services.feature_service import FeatureService+from services.file_service import FileService+from services.remote_file_service import RemoteFileService+from services.trial_app_access_service import TrialAppAccessService++_Endpoint = Literal["files/upload", "remote-files/upload"]+_CREATED_AT = datetime(2024, 1, 1)+_REMOTE_URL = "https://example.com/trial.txt"+_CONTENT = b"trial upload"+++@dataclass+class _Features:+ enabled: bool = True+ events: list[str] = field(default_factory=list)++ def is_trial_enabled(self) -> bool:+ self.events.append("feature")+ return self.enabled+++@dataclass+class _ExternalIO:+ admission_sessions: list[Session]+ saved: dict[str, bytes] = field(default_factory=dict)+ requests: list[tuple[str, str, Mapping[str, object]]] = field(default_factory=list)+ head_status: int = 200+ get_status: int = 200+ content_length: str = str(len(_CONTENT))+ error: Exception | None = None++ def assert_admission_closed(self) -> None:+ assert self.admission_sessions+ assert all(not session.in_transaction() and not session.identity_map for session in self.admission_sessions)++ def save(self, key: str, content: bytes) -> None:+ self.assert_admission_closed()+ self.saved[key] = content++ def request(self, method: str, *, url: str, **kwargs: object) -> httpx.Response:+ self.assert_admission_closed()+ self.requests.append((method, url, kwargs))+ if self.error is not None:+ raise self.error+ return httpx.Response(+ self.head_status if method == "HEAD" else self.get_status,+ headers={"Content-Type": "text/plain", "Content-Length": self.content_length},+ content=_CONTENT if method == "GET" else b"",+ request=httpx.Request(method, url),+ )+++@dataclass(frozen=True)+class _ApplicationServices:+ trial_app_access: TrialAppAccessService+ recommended_app_queries: _Features+ files: FileService+ remote_files: RemoteFileService+++@dataclass(frozen=True)+class _Harness:+ app: Flask+ account: Account+ target: App+ trial: TrialApp+ factory: sessionmaker[Session]+ features: _Features+ io: _ExternalIO++ def url(self, endpoint: _Endpoint) -> str:+ return f"/trial-apps/{self.target.id}/{endpoint}"++ def post(self, endpoint: _Endpoint, *, query: str = "") -> TestResponse:+ if endpoint == "remote-files/upload":+ return self.app.test_client().post(self.url(endpoint) + query, json={"url": _REMOTE_URL})+ return self.app.test_client().post(+ self.url(endpoint) + query,+ data={"file": (BytesIO(_CONTENT), "trial.txt", "text/plain")},+ )++ def uploaded(self) -> list[UploadFile]:+ with self.factory() as session:+ return list(session.scalars(select(UploadFile)))++ def usage(self) -> int | None:+ with self.factory() as session:+ return session.scalar(+ select(AccountTrialAppRecord.count).where(+ AccountTrialAppRecord.app_id == self.target.id,+ AccountTrialAppRecord.account_id == self.account.id,+ )+ )+++def harness(+ monkeypatch: pytest.MonkeyPatch,+ config_overrides: Callable[..., None],+ sqlite_session_factory: sessionmaker[Session],+) -> _Harness:+ config_overrides(+ DEPLOYMENT_EDITION=DeploymentEdition.COMMUNITY,+ INIT_PASSWORD="",+ LOGIN_DISABLED=False,+ RBAC_ENABLED=False,+ UPLOAD_FILE_SIZE_LIMIT=1,+ inner_UPLOAD_FILE_EXTENSION_BLACKLIST="exe",+ )+ features = _Features()+ account = Account(name="Trial viewer", email="[email protected]")+ account._current_tenant = Tenant(name="Viewer workspace")+ account.role = TenantAccountRole.OWNER+ target = App(tenant_id=str(uuid4()), name="Trial app", mode=AppMode.CHAT, enable_site=True, enable_api=False)+ target.id = str(uuid4())+ trial = TrialApp(app_id=target.id, tenant_id=str(uuid4()), trial_limit=3)+ with sqlite_session_factory.begin() as session:+ session.add_all([target, trial])++ sessions: list[Session] = []+ repository_factory = sessionmaker(bind=sqlite_session_factory.kw["bind"], expire_on_commit=False)++ @event.listens_for(repository_factory, "after_begin")+ def track_session(session: Session, _transaction: SessionTransaction, _connection: Connection) -> None:+ sessions.append(session)++ io = _ExternalIO(sessions)+ files = FileService(session_factory=sqlite_session_factory)+ services = _ApplicationServices(+ trial_app_access=TrialAppAccessService(apps=TrialAppRepository(session_factory=repository_factory)),+ recommended_app_queries=features,+ files=files,+ remote_files=RemoteFileService(files=files),+ )++ def setup_completed() -> bool:+ features.events.append("setup")+ return True++ def csrf(_request: Request, account_id: str) -> None:+ assert account_id == account.id+ features.events.append("csrf")++ for module in (trial_module, admission_module, files_module, remote_module):+ monkeypatch.setattr(module, "application_services", lambda: services)+ monkeypatch.setattr(console_wraps, "_is_setup_completed", setup_completed)+ monkeypatch.setattr(login_module, "current_user", account)+ monkeypatch.setattr(login_module, "check_csrf_token", csrf)+ monkeypatch.setattr(file_module.storage, "save", io.save)+ monkeypatch.setattr(file_module, "naive_utc_now", lambda: _CREATED_AT)+ monkeypatch.setattr(remote_fetcher, "make_request", io.request)++ app = Flask(__name__)+ app.config.update(TESTING=True, RESTX_ERROR_404_HELP=False)+ login_manager = DifyLoginManager()+ login_manager.init_app(app)+ login_manager.unauthorized_handler(unauthorized_handler)+ api = ExternalApi(app)+ api.add_resource(trial_module.TrialAppFileUploadApi, "/trial-apps/<uuid:app_id>/files/upload")+ api.add_resource(trial_module.TrialAppRemoteFileUploadApi, "/trial-apps/<uuid:app_id>/remote-files/upload")+ return _Harness(app, account, target, trial, sqlite_session_factory, features, io)+++def _assert_error(response: TestResponse, status: int, code: str) -> None:+ assert response.status_code == status, response.get_json()+ body = response.get_json()+ assert isinstance(body, dict)+ assert body["code"] == code+ assert body["status"] == status+ assert isinstance(body["message"], str)+ assert body["message"]+ assert response.headers["Content-Type"] == "application/json"+++def _assert_signed_url(url: object, file_id: str) -> None:+ assert isinstance(url, str)+ parsed = urlsplit(url)+ assert parsed.path == f"/files/{file_id}/file-preview"+ assert parse_qs(parsed.query).keys() == {"timestamp", "nonce", "sign"}++[email protected]("content", [_CONTENT, b""])+def test_local_upload_preserves_complete_response_and_owner_tenant(harness: _Harness, content: bytes) -> None:+ response = harness.app.test_client().post(+ harness.url("files/upload"), data={"file": (BytesIO(content), "trial.txt", "text/plain")}+ )++ assert response.status_code == 201+ assert response.headers["Content-Type"] == "application/json"+ assert int(response.headers["Content-Length"]) == len(response.data)+ body = response.get_json()+ uploaded = harness.uploaded()+ assert len(uploaded) == 1+ file = uploaded[0]+ assert body == {+ "id": file.id,+ "reference": None,+ "name": "trial.txt",+ "size": len(content),+ "extension": "txt",+ "mime_type": "text/plain",+ "created_by": harness.account.id,+ "created_at": int(_CREATED_AT.timestamp()),+ "preview_url": None,+ "source_url": body["source_url"],+ "original_url": None,+ "user_id": None,+ "tenant_id": harness.target.tenant_id,+ "conversation_id": None,+ "file_key": None,+ }+ assert str(UUID(file.id)) == file.id+ _assert_signed_url(body["source_url"], file.id)+ assert file.created_by_role == CreatorUserRole.ACCOUNT+ assert file.created_by == harness.account.id+ assert file.tenant_id == harness.target.tenant_id+ assert file.tenant_id not in {harness.trial.tenant_id, harness.account.current_tenant_id}+ assert file.key.startswith(f"upload_files/{file.tenant_id}/")+ assert file.hash == hashlib.sha3_256(content).hexdigest()+ assert file.used is False+ assert harness.io.saved == {file.key: content}+ assert harness.features.events == ["setup", "csrf", "feature"]+ assert harness.usage() is None++[email protected]("head_status", [200, 405])+def test_remote_upload_fetches_once_and_preserves_response_and_actor(harness: _Harness, head_status: int) -> None:+ harness.io.head_status = head_status+ response = harness.post("remote-files/upload")++ assert response.status_code == 201+ assert response.headers["Content-Type"] == "application/json"+ assert int(response.headers["Content-Length"]) == len(response.data)+ body = response.get_json()+ uploaded = harness.uploaded()+ assert len(uploaded) == 1+ file = uploaded[0]+ assert body == {+ "id": file.id,+ "name": "trial.txt",+ "size": len(_CONTENT),+ "extension": "txt",+ "url": body["url"],+ "mime_type": "text/plain",+ "created_by": harness.account.id,+ "created_at": int(_CREATED_AT.timestamp()),+ }+ _assert_signed_url(body["url"], file.id)+ assert file.source_url == _REMOTE_URL+ assert file.tenant_id == harness.target.tenant_id+ assert file.tenant_id not in {harness.trial.tenant_id, harness.account.current_tenant_id}+ assert file.created_by == harness.account.id+ assert file.created_by_role == CreatorUserRole.ACCOUNT+ assert harness.io.saved == {file.key: _CONTENT}+ assert harness.io.requests == [+ ("HEAD", _REMOTE_URL, {}),+ ("GET", _REMOTE_URL, {} if head_status == 200 else {"timeout": 3, "follow_redirects": True}),+ ]+ assert harness.usage() is None++[email protected]("endpoint", ["files/upload", "remote-files/upload"])+ ("denial", "code"),+ [+ ("feature", "trial_app_feature_disabled"),+ ("missing_trial", "trial_app_not_allowed"),+ ("missing_app", "trial_app_not_allowed"),+ ("quota", "trial_app_limit_exceeded"),+ ],+)+def test_trial_admission_rejects_before_parsing_or_external_io(+ harness: _Harness, endpoint: _Endpoint, denial: str, code: str+) -> None:+ if denial == "feature":+ harness.features.enabled = False+ else:+ with harness.factory.begin() as session:+ if denial == "missing_trial":+ session.execute(delete(TrialApp).where(TrialApp.app_id == harness.target.id))+ elif denial == "missing_app":+ session.execute(delete(App).where(App.id == harness.target.id))+ else:+ session.add(AccountTrialAppRecord(app_id=harness.target.id, account_id=harness.account.id, count=3))++ response = harness.app.test_client().post(harness.url(endpoint), json={})++ _assert_error(response, 403, code)+ assert harness.io.saved == {}+ assert harness.io.requests == []+ assert harness.uploaded() == []+ assert harness.usage() == (3 if denial == "quota" else None)+ if denial == "feature":+ assert harness.io.admission_sessions == []+ else:+ harness.io.assert_admission_closed()++[email protected]("endpoint", ["files/upload", "remote-files/upload"])+def test_upload_does_not_charge_usage_or_inherit_another_accounts_exhausted_quota(+ harness: _Harness, endpoint: _Endpoint+) -> None:+ other_account_id = str(uuid4())+ with harness.factory.begin() as session:+ session.add_all(+ [+ AccountTrialAppRecord(app_id=harness.target.id, account_id=harness.account.id, count=1),+ AccountTrialAppRecord(app_id=harness.target.id, account_id=other_account_id, count=3),+ ]+ )++ response = harness.post(endpoint)++ assert response.status_code == 201+ assert harness.usage() == 1+ with harness.factory() as session:+ assert (+ session.scalar(+ select(AccountTrialAppRecord.count).where(AccountTrialAppRecord.account_id == other_account_id)+ )+ == 3+ )+++ ("shape", "code"),+ [("missing", "no_file_uploaded"), ("multiple", "too_many_files"), ("empty_name", "filename_not_exists_error")],+)+def test_multipart_shape_errors_precede_dataset_permissions(harness: _Harness, shape: str, code: str) -> None:+ harness.account.role = TenantAccountRole.NORMAL+ data = {}+ if shape != "missing":+ data["file"] = (BytesIO(_CONTENT), "" if shape == "empty_name" else "trial.txt", "text/plain")+ if shape == "multiple":+ data["second_file"] = (BytesIO(_CONTENT), "second.txt", "text/plain")++ response = harness.app.test_client().post(harness.url("files/upload") + "?source=datasets", data=data)++ _assert_error(response, 400, code)+ assert harness.io.saved == {}+ assert harness.uploaded() == []+++ ("query_source", "form_source", "status"),+ [("datasets", "unknown", 403), ("unknown", "datasets", 201), ("", "datasets", 403)],+)+def test_query_source_takes_precedence_over_form_before_active_workspace_permission(+ harness: _Harness, query_source: str, form_source: str, status: int+) -> None:+ harness.account.role = TenantAccountRole.NORMAL+ response = harness.app.test_client().post(+ harness.url("files/upload") + f"?source={query_source}",+ data={"file": (BytesIO(_CONTENT), "trial.txt", "text/plain"), "source": form_source},+ )++ assert response.status_code == status+ if status == 403:+ _assert_error(response, status, "forbidden")+ assert harness.io.saved == {}+ else:+ assert len(harness.uploaded()) == 1+++ ("role", "rbac", "status"),+ [+ (TenantAccountRole.OWNER, False, 201),+ (TenantAccountRole.DATASET_OPERATOR, False, 201),+ (TenantAccountRole.NORMAL, False, 403),+ (TenantAccountRole.NORMAL, True, 201),+ ],+)+def test_dataset_upload_uses_active_workspace_role_and_retains_rbac_bypass(+ harness: _Harness, config_overrides: Callable[..., None], role: TenantAccountRole, rbac: bool, status: int+) -> None:+ harness.account.role = role+ config_overrides(RBAC_ENABLED=rbac)++ response = harness.post("files/upload", query="?source=datasets")++ assert response.status_code == status+ assert len(harness.uploaded()) == (1 if status == 201 else 0)++[email protected]("endpoint", ["files/upload", "remote-files/upload"])+def test_cloud_document_quota_uses_active_workspace_before_upload(+ harness: _Harness, monkeypatch: pytest.MonkeyPatch, config_overrides: Callable[..., None], endpoint: _Endpoint+) -> None:+ config_overrides(DEPLOYMENT_EDITION=DeploymentEdition.CLOUD)+ checked_tenants: list[str] = []++ def get_features(tenant_id: str, exclude_vector_space: bool = False) -> FeatureModel:+ checked_tenants.append(tenant_id)+ assert exclude_vector_space is True+ features = FeatureModel()+ features.documents_upload_quota.limit = 1+ features.documents_upload_quota.size = 1+ return features++ monkeypatch.setattr(FeatureService, "get_features", get_features)++ response = harness.post(endpoint, query="?source=datasets")++ _assert_error(response, 403, "forbidden")+ assert checked_tenants == [harness.account.current_tenant_id]+ assert harness.io.saved == {}+ assert harness.io.requests == []+ assert harness.usage() is None+++def test_dataset_file_size_limit_comes_from_app_owner_tenant(+ harness: _Harness, monkeypatch: pytest.MonkeyPatch, config_overrides: Callable[..., None]+) -> None:+ config_overrides(DEPLOYMENT_EDITION=DeploymentEdition.CLOUD)+ quota_tenants: list[str] = []+ size_limit_tenants: list[str | None] = []++ def get_features(tenant_id: str, exclude_vector_space: bool = False) -> FeatureModel:+ quota_tenants.append(tenant_id)+ assert exclude_vector_space is True+ return FeatureModel()++ def get_size_limit(tenant_id: str | None) -> int:+ size_limit_tenants.append(tenant_id)+ return 0++ monkeypatch.setattr(FeatureService, "get_features", get_features)+ monkeypatch.setattr(FeatureService, "get_knowledge_file_size_limit", get_size_limit)++ response = harness.post("files/upload", query="?source=datasets")++ _assert_error(response, 413, "file_too_large")+ assert response.get_json()["message"] == "File size exceeded."+ assert quota_tenants == [harness.account.current_tenant_id]+ assert size_limit_tenants == [harness.target.tenant_id]+ assert harness.io.saved == {}+ assert harness.uploaded() == []+++ ("filename", "query", "status", "code"),+ [("trial.exe", "", 400, "file_extension_blocked"), ("trial.png", "?source=datasets", 415, "unsupported_file_type")],+)+def test_local_file_policy_errors_keep_specific_codes(+ harness: _Harness, filename: str, query: str, status: int, code: str+) -> None:+ response = harness.app.test_client().post(+ harness.url("files/upload") + query, data={"file": (BytesIO(_CONTENT), filename, "application/octet-stream")}+ )++ _assert_error(response, status, code)+ assert harness.io.saved == {}+ assert harness.uploaded() == []+++ ("get_status", "status", "code"),+ [+ (404, 404, "remote_file_not_found"),+ (403, 400, "remote_file_access_denied"),+ (503, 502, "remote_file_unavailable"),+ ],+)+def test_remote_http_failures_keep_precise_error_codes(+ harness: _Harness, get_status: int, status: int, code: str+) -> None:+ harness.io.head_status = 405+ harness.io.get_status = get_status++ response = harness.post("remote-files/upload")++ _assert_error(response, status, code)+ assert [method for method, _url, _kwargs in harness.io.requests] == ["HEAD", "GET"]+ assert harness.io.saved == {}+ assert harness.uploaded() == []+ assert harness.usage() is None+++ ("failure", "status", "code"),+ [+ ("blocked", 400, "remote_file_url_blocked"),+ ("timeout", 502, "remote_file_unavailable"),+ ("metadata", 502, "remote_file_invalid_response"),+ ("size", 413, "file_too_large"),+ ],+)+def test_remote_transport_metadata_and_size_failures_prevent_storage(+ harness: _Harness, failure: str, status: int, code: str+) -> None:+ if failure == "blocked":+ harness.io.error = ToolSSRFError("Blocked by SSRF proxy")+ elif failure == "timeout":+ harness.io.error = httpx.ReadTimeout("Timed out")+ elif failure == "metadata":+ harness.io.content_length = "invalid"+ else:+ harness.io.content_length = str(1024 * 1024 + 1)++ response = harness.post("remote-files/upload")++ _assert_error(response, status, code)+ assert len(harness.io.requests) == 1+ assert harness.io.saved == {}+ assert harness.uploaded() == []+ assert harness.usage() is None+++def test_remote_invalid_url_fails_before_network(harness: _Harness) -> None:+ response = harness.app.test_client().post(harness.url("remote-files/upload"), json={"url": "file:///etc/passwd"})++ _assert_error(response, 400, "remote_file_invalid_url")+ assert harness.io.requests == []+ assert harness.io.saved == {}+++def test_remote_payload_validation_stays_on_http_boundary(harness: _Harness) -> None:+ response = harness.app.test_client().post(harness.url("remote-files/upload"), json={})++ assert response.status_code == 422+ assert "url" in response.get_json()["message"]+ assert harness.io.requests == []+ assert harness.io.saved == {}diff --git a/api/tests/unit_tests/services/test_file_service.py b/api/tests/unit_tests/services/test_file_service.pyindex 22106b85cc1..bd35f39506a 100644--- a/api/tests/unit_tests/services/test_file_service.py+++ b/api/tests/unit_tests/services/test_file_service.py@@ -235,6 +235,8 @@ class TestFileService:# Defaultassert FileService.is_file_size_within_limit(extension="txt", file_size=5 * 1024 * 1024) is Trueassert FileService.is_file_size_within_limit(extension="pdf", file_size=6 * 1024 * 1024) is False+ assert FileService.is_file_size_within_limit(extension="txt", file_size=0, default_file_size_limit=0) is True+ assert FileService.is_file_size_within_limit(extension="txt", file_size=1, default_file_size_limit=0) is Falseassert (FileService.is_file_size_within_limit(extension="pdf",@@ -274,6 +276,9 @@ class TestFileService:assert FileService.file_size_limit(extension="mp4") == 20 * 1024 * 1024assert FileService.file_size_limit(extension="mp3") == 30 * 1024 * 1024assert FileService.file_size_limit(extension="txt") == 5 * 1024 * 1024+ assert FileService.file_size_limit(extension="txt", default_file_size_limit=None) == 5 * 1024 * 1024+ assert FileService.file_size_limit(extension="txt", default_file_size_limit=0) == 0+ assert FileService.file_size_limit(extension="jpg", default_file_size_limit=0) == 10 * 1024 * 1024assert FileService.file_size_limit(extension="txt", default_file_size_limit=7) == 7 * 1024 * 1024def test_get_file_base64_success(self, file_service: FileService, db_session: Session):diff --git a/api/tests/unit_tests/services/test_file_upload_actor.py b/api/tests/unit_tests/services/test_file_upload_actor.pynew file mode 100644index 00000000000..9efe37cf4d9--- /dev/null+++ b/api/tests/unit_tests/services/test_file_upload_actor.py@@ -0,0 +1,232 @@+import hashlib+from collections.abc import Iterator+from dataclasses import dataclass+from datetime import datetime++import httpx+import pytest+from sqlalchemy import Connection, Engine, event, select+from sqlalchemy.orm import Session, sessionmaker++from core.file import remote_fetcher+from extensions.ext_storage import storage+from graphon.file import helpers as file_helpers+from models.enums import CreatorUserRole+from models.model import UploadFile+from services.file_service import FileService, FileUploadActor, FileUploadResult+from services.remote_file_service import RemoteFileService++_TENANT_ID = "11111111-1111-1111-1111-111111111111"+_ACTOR_ID = "22222222-2222-2222-2222-222222222222"+_REMOTE_URL = "https://example.com/report.txt"+++@dataclass+class _UploadHarness:+ files: FileService+ stored: dict[str, bytes]+ active_transactions: set[Connection]+ io_events: list[str]+ database_events: list[str]+++def upload_harness(+ sqlite_engine: Engine,+ sqlite_session_factory: sessionmaker[Session],+ monkeypatch: pytest.MonkeyPatch,+) -> Iterator[_UploadHarness]:+ harness = _UploadHarness(+ files=FileService(session_factory=sqlite_session_factory),+ stored={},+ active_transactions=set(),+ io_events=[],+ database_events=[],+ )++ def begin(connection: Connection) -> None:+ harness.active_transactions.add(connection)+ harness.database_events.append("begin")++ def end(connection: Connection) -> None:+ harness.active_transactions.remove(connection)+ harness.database_events.append("end")++ def save(key: str, content: bytes) -> None:+ assert not harness.active_transactions+ harness.io_events.append("storage")+ harness.stored[key] = content++ def signed_url(upload_file_id: str) -> str:+ assert not harness.active_transactions+ harness.io_events.append("sign")+ return f"https://files.example.com/{upload_file_id}?sign=test"++ event.listen(sqlite_engine, "begin", begin)+ event.listen(sqlite_engine, "commit", end)+ event.listen(sqlite_engine, "rollback", end)+ monkeypatch.setattr(storage, "save", save)+ monkeypatch.setattr(file_helpers, "get_signed_file_url", signed_url)+ try:+ yield harness+ finally:+ event.remove(sqlite_engine, "begin", begin)+ event.remove(sqlite_engine, "commit", end)+ event.remove(sqlite_engine, "rollback", end)++[email protected]("role", [CreatorUserRole.ACCOUNT, CreatorUserRole.END_USER])[email protected]("source_url", ["", _REMOTE_URL])+def test_actor_upload_preserves_owner_creator_and_source_url_without_extra_queries(+ upload_harness: _UploadHarness,+ sqlite_session_factory: sessionmaker[Session],+ role: CreatorUserRole,+ source_url: str,+) -> None:+ actor = FileUploadActor(id=_ACTOR_ID, creator_role=role)+ content = "文件内容".encode()++ result = upload_harness.files.upload_file_for_actor(+ actor=actor,+ resource_tenant_id=_TENANT_ID,+ filename="report.TXT",+ content=content,+ mimetype="text/plain",+ source_url=source_url,+ )++ assert isinstance(result, FileUploadResult)+ assert result.name == "report.TXT"+ assert result.size == len(content)+ assert result.extension == "txt"+ assert result.mime_type == "text/plain"+ assert result.created_by == actor.id+ assert isinstance(result.created_at, datetime)+ assert result.tenant_id == _TENANT_ID+ assert result.source_url == (source_url or f"https://files.example.com/{result.id}?sign=test")+ assert upload_harness.database_events == ["begin", "end"]+ assert not upload_harness.active_transactions+ assert upload_harness.io_events == (["storage"] if source_url else ["storage", "sign"])++ with sqlite_session_factory() as session:+ persisted = session.get(UploadFile, result.id)+ assert persisted is not None+ assert persisted.created_by_role == role+ assert persisted.created_by == actor.id+ assert persisted.tenant_id == _TENANT_ID+ assert persisted.source_url == source_url+ assert persisted.hash == hashlib.sha3_256(content).hexdigest()+ assert persisted.key.startswith(f"upload_files/{_TENANT_ID}/")+ assert upload_harness.stored == {persisted.key: content}++[email protected]("head_status", [httpx.codes.OK, httpx.codes.METHOD_NOT_ALLOWED])+def test_remote_actor_upload_fetches_before_transaction_and_retains_original_url(+ upload_harness: _UploadHarness,+ sqlite_session_factory: sessionmaker[Session],+ monkeypatch: pytest.MonkeyPatch,+ head_status: int,+) -> None:+ actor = FileUploadActor(id=_ACTOR_ID, creator_role=CreatorUserRole.ACCOUNT)+ content = b"remote file content"+ requests: list[tuple[str, dict[str, object]]] = []++ def make_request(method: str, *, url: str, **kwargs: object) -> httpx.Response:+ assert not upload_harness.active_transactions+ assert url == _REMOTE_URL+ requests.append((method, kwargs))+ upload_harness.io_events.append(method)+ return httpx.Response(+ head_status if method == "HEAD" else httpx.codes.OK,+ content=content if method == "GET" else b"",+ headers={"Content-Type": "text/plain", "Content-Length": str(len(content))},+ request=httpx.Request(method, url),+ )++ monkeypatch.setattr(remote_fetcher, "make_request", make_request)++ result = RemoteFileService(files=upload_harness.files).upload_from_url(+ url=_REMOTE_URL, user=actor, tenant_id=_TENANT_ID+ )++ assert result.name == "report.txt"+ assert result.size == len(content)+ assert result.extension == "txt"+ assert result.mime_type == "text/plain"+ assert result.created_by == actor.id+ assert result.url == f"https://files.example.com/{result.id}?sign=test"+ assert requests == [+ ("HEAD", {}),+ ("GET", {} if head_status == httpx.codes.OK else {"timeout": 3, "follow_redirects": True}),+ ]+ assert upload_harness.io_events == ["HEAD", "GET", "storage", "sign"]+ assert upload_harness.database_events == ["begin", "end"]+ assert not upload_harness.active_transactions++ with sqlite_session_factory() as session:+ persisted = session.scalars(select(UploadFile)).one()+ assert persisted.id == result.id+ assert persisted.created_by == actor.id+ assert persisted.created_by_role == CreatorUserRole.ACCOUNT+ assert persisted.tenant_id == _TENANT_ID+ assert persisted.source_url == _REMOTE_URL+ assert persisted.key.startswith(f"upload_files/{_TENANT_ID}/")+ assert upload_harness.stored == {persisted.key: content}+++def test_same_actor_can_upload_to_separately_admitted_tenants(+ upload_harness: _UploadHarness,+ sqlite_session_factory: sessionmaker[Session],+) -> None:+ actor = FileUploadActor(id=_ACTOR_ID, creator_role=CreatorUserRole.ACCOUNT)+ tenant_ids = (_TENANT_ID, "33333333-3333-3333-3333-333333333333")++ results = [+ upload_harness.files.upload_file_for_actor(+ actor=actor,+ resource_tenant_id=tenant_id,+ filename="report.txt",+ content=tenant_id.encode(),+ mimetype="text/plain",+ )+ for tenant_id in tenant_ids+ ]++ assert [result.tenant_id for result in results] == list(tenant_ids)+ assert len({result.id for result in results}) == 2+ with sqlite_session_factory() as session:+ for result, tenant_id in zip(results, tenant_ids, strict=True):+ persisted = session.get(UploadFile, result.id)+ assert persisted is not None+ assert persisted.tenant_id == tenant_id+ assert persisted.created_by == actor.id+ assert persisted.created_by_role == actor.creator_role+ assert persisted.key.startswith(f"upload_files/{tenant_id}/")+ assert upload_harness.stored[persisted.key] == tenant_id.encode()++[email protected]("remote", [False, True], ids=["local", "remote"])+def test_actor_upload_without_target_tenant_fails_before_external_io(+ upload_harness: _UploadHarness,+ monkeypatch: pytest.MonkeyPatch,+ remote: bool,+) -> None:+ actor = FileUploadActor(id=_ACTOR_ID, creator_role=CreatorUserRole.ACCOUNT)++ def unexpected_request(*_args: object, **_kwargs: object) -> httpx.Response:+ pytest.fail("Missing target tenant must be rejected before fetching the remote file")++ monkeypatch.setattr(remote_fetcher, "make_request", unexpected_request)++ if remote:+ with pytest.raises(TypeError, match="tenant_id"):+ RemoteFileService(files=upload_harness.files).upload_from_url(url=_REMOTE_URL, user=actor)+ else:+ with pytest.raises(TypeError, match="tenant_id"):+ upload_harness.files.upload_file(+ filename="report.txt", content=b"file content", mimetype="text/plain", user=actor+ )++ assert upload_harness.io_events == []+ assert upload_harness.database_events == []+ assert upload_harness.stored == {}