Skip to content

armgit / dify

Public Imported from GitHub
0

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.

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.py
index 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 ParametersResponse
from controllers.common.fields import Site as SiteResponse
from 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_app
from 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_context
from controllers.console.flask_admission import console_account_admission
from controllers.console.remote_files import RemoteFileUploadPayload, upload_remote_file
from controllers.console.wraps import cloud_edition_billing_resource_check, model_validate, with_current_user
@@ -72,8 +73,9 @@ from graphon.variables import SecretVariable, VariableBase
from libs import helper
from libs.helper import dump_response, to_timestamp, uuid_value
from machinery.context import RequestContext
-from models import Account, App
+from models import Account
from models.account import TenantStatus
+from models.enums import CreatorUserRole
from models.model import AppMode, Site
from models.workflow import Workflow
from services.account_errors import AccountNotFoundError
@@ -96,6 +98,7 @@ from services.errors.message import (
MessageNotExistsError,
SuggestedQuestionsAfterAnswerDisabledError,
)
+from services.file_service import FileUploadActor
from services.message_service import MessageService
from services.trial_app_access_service import TrialAppRef
from 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), 201
diff --git a/api/controllers/console/files.py b/api/controllers/console/files.py
index 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 contextmanager
from typing import Literal
from uuid import UUID
from flask import request
from flask_restx import Resource
+from werkzeug.datastructures import FileStorage
from werkzeug.exceptions import Forbidden
import services
@@ -29,10 +32,12 @@ from controllers.console.wraps import (
from extensions.ext_application_services import application_services
from fields.file_fields import FileResponse, UploadConfig
from libs.helper import dump_response
-from libs.login import login_required
+from libs.login import current_account_with_tenant, login_required
from machinery.context import RequestContext
from models import Account, UploadFile
+from models.enums import CreatorUserRole
from services.feature_service import FeatureService
+from services.file_service import FileUploadActor, FileUploadResult
register_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.py
index 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 request
from flask_restx import Resource
from pydantic import BaseModel, Field
@@ -25,6 +27,7 @@ from libs.helper import dump_response
from libs.login import login_required
from machinery.context import RequestContext
from models import Account
+from services.file_service import FileUploadActor
from services.remote_file_service import (
RemoteFileAccessDeniedError as RemoteFileAccessDeniedServiceError,
)
@@ -84,13 +87,37 @@ class GetRemoteFileInfo(Resource):
)
+@overload
def 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.py
index e06069c8cc2..eaae6065320 100644
--- a/api/services/file_service.py
+++ b/api/services/file_service.py
@@ -5,6 +5,8 @@ import posixpath
import uuid
from collections.abc import Generator, Sequence # Changed Iterator to Generator
from contextlib import contextmanager, suppress
+from dataclasses import dataclass
+from datetime import datetime
from tempfile import NamedTemporaryFile
from typing import Literal
from zipfile import ZIP_DEFLATED, ZipFile
@@ -36,6 +38,27 @@ from .errors.file import BlockedFileExtensionError, FileNotExistsError, FileTooL
PREVIEW_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 extension
extension = os.path.splitext(filename)[1].lstrip(".").lower()
@@ -92,7 +129,12 @@ class FileService:
# generate file key
file_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_USER
file_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,
+ )
+
@staticmethod
def 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_LIMIT
diff --git a/api/services/remote_file_service.py b/api/services/remote_file_service.py
index 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_helpers
from models import Account
from models.model import EndUser
from 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.py
index 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, StringVariable
from models import Account, Tenant
from models.account import TenantStatus
from models.dataset import Dataset
-from models.model import App, AppMode, Site, UploadFile
+from models.model import App, AppMode, Site
from models.tools import WorkflowToolProvider
from models.workflow import Workflow
from services.app_ref_service import AppRef, MessageRef
from services.errors.audio import SpeechToTextDisabledServiceError
from 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_app
unwrap: 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.py
new file mode 100644
index 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.py
index 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:
# Default
assert FileService.is_file_size_within_limit(extension="txt", file_size=5 * 1024 * 1024) is True
assert 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 False
assert (
FileService.is_file_size_within_limit(
extension="pdf",
@@ -274,6 +276,9 @@ class TestFileService:
assert FileService.file_size_limit(extension="mp4") == 20 * 1024 * 1024
assert FileService.file_size_limit(extension="mp3") == 30 * 1024 * 1024
assert 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 * 1024
assert FileService.file_size_limit(extension="txt", default_file_size_limit=7) == 7 * 1024 * 1024
def 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.py
new file mode 100644
index 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 == {}