Files
FileCodeBox/tests/test_presign_upload_flow.py

272 lines
9.3 KiB
Python

import asyncio
import unittest
from datetime import timedelta
from types import SimpleNamespace
from fastapi import HTTPException
import apps.base.views as views
from apps.base.schemas import PresignUploadInitRequest
from core.settings import settings
from core.utils import get_now
class SettingsOverrideMixin:
def setUp(self):
self._original_user_config = dict(settings.user_config)
def tearDown(self):
settings.user_config = self._original_user_config
class FakeUploadLimiter:
def __init__(self):
self.added_ips = []
def add_ip(self, ip):
self.added_ips.append(ip)
class FakeUploadFile:
def __init__(self, size):
self.size = size
self.filename = "upload.txt"
self.content_type = "text/plain"
class FakeStorage:
def __init__(self, presigned_url=None, exists=True):
self.presigned_url = presigned_url
self.exists = exists
self.saved = []
self.deleted = []
async def generate_presigned_upload_url(self, save_path, expires_in):
self.last_presign_request = (save_path, expires_in)
return self.presigned_url
async def save_file(self, file, save_path):
self.saved.append((file, save_path))
async def file_exists(self, save_path):
self.last_exists_path = save_path
return self.exists
async def delete_file(self, file_code):
self.deleted.append(file_code)
class FakeSession:
def __init__(self, mode="direct", file_size=12, expired=False):
self.upload_id = "upload-1"
self.file_name = "upload.txt"
self.file_size = file_size
self.save_path = "share/data/2026/06/06/upload-1/upload.txt"
self.mode = mode
self.expire_value = 2
self.expire_style = "day"
self.created_at = None
self.expires_at = None
self.expired = expired
self.deleted = False
async def is_expired(self):
return self.expired
async def delete(self):
self.deleted = True
class FakeSessionQuery:
def __init__(self, session):
self.session = session
async def first(self):
return self.session
class FakePresignUploadSession:
created_payload = None
session = None
@classmethod
async def create(cls, **kwargs):
cls.created_payload = kwargs
return SimpleNamespace(**kwargs)
@classmethod
def filter(cls, **kwargs):
cls.filter_kwargs = kwargs
return FakeSessionQuery(cls.session)
class FakeFileUploadService:
created_records = []
@staticmethod
async def generate_file_path(file_name, upload_id=None):
filename = file_name.strip()
return (
f"share/data/2026/06/06/{upload_id}",
".txt",
"upload",
filename,
f"share/data/2026/06/06/{upload_id}/{filename}",
)
@classmethod
async def create_file_record(
cls, file_name, file_size, file_path, expire_value, expire_style, **extra_fields
):
cls.created_records.append(
{
"file_name": file_name,
"file_size": file_size,
"file_path": file_path,
"expire_value": expire_value,
"expire_style": expire_style,
**extra_fields,
}
)
return "12345"
class PresignUploadFlowTests(SettingsOverrideMixin, unittest.TestCase):
def setUp(self):
super().setUp()
self._original_storages = dict(views.storages)
self._original_session_model = views.PresignUploadSession
self._original_file_upload_service = views.FileUploadService
self._original_upload_limiter = views.ip_limit["upload"]
self.storage = FakeStorage()
views.storages = {"local": lambda: self.storage}
views.PresignUploadSession = FakePresignUploadSession
views.FileUploadService = FakeFileUploadService
views.ip_limit["upload"] = FakeUploadLimiter()
FakePresignUploadSession.created_payload = None
FakePresignUploadSession.session = None
FakeFileUploadService.created_records = []
settings.file_storage = "local"
settings.uploadSize = 1024
settings.allowed_file_types = ["*"]
settings.expireStyle = ["day", "hour", "minute", "forever", "count"]
def tearDown(self):
views.storages = self._original_storages
views.PresignUploadSession = self._original_session_model
views.FileUploadService = self._original_file_upload_service
views.ip_limit["upload"] = self._original_upload_limiter
super().tearDown()
def test_init_returns_proxy_urls_when_storage_has_no_presigned_url(self):
response = asyncio.run(
views.presign_upload_init(
PresignUploadInitRequest(
file_name="upload.txt",
file_size=12,
expire_value=2,
expire_style="day",
),
ip="127.0.0.1",
)
)
detail = response.detail
self.assertEqual(detail["mode"], "proxy")
self.assertEqual(detail["upload_url"], detail["proxy_upload_url"])
self.assertEqual(detail["legacy_proxy_upload_url"], f"/api{detail['proxy_upload_url']}")
self.assertEqual(FakePresignUploadSession.created_payload["file_name"], "upload.txt")
self.assertEqual(FakePresignUploadSession.created_payload["file_size"], 12)
self.assertEqual(views.ip_limit["upload"].added_ips, ["127.0.0.1"])
def test_init_returns_direct_url_when_storage_supports_presigned_upload(self):
self.storage.presigned_url = "https://storage.example/upload"
response = asyncio.run(
views.presign_upload_init(
PresignUploadInitRequest(file_name="upload.txt", file_size=12),
ip="127.0.0.1",
)
)
self.assertEqual(response.detail["mode"], "direct")
self.assertEqual(response.detail["upload_url"], "https://storage.example/upload")
self.assertNotIn("proxy_upload_url", response.detail)
def test_init_rejects_disallowed_expiration_style(self):
with self.assertRaises(HTTPException) as error:
asyncio.run(
views.presign_upload_init(
PresignUploadInitRequest(
file_name="upload.txt",
file_size=12,
expire_style="week",
),
ip="127.0.0.1",
)
)
self.assertEqual(error.exception.status_code, 400)
def test_confirm_requires_uploaded_direct_file_before_creating_record(self):
FakePresignUploadSession.session = FakeSession(mode="direct")
self.storage.exists = True
response = asyncio.run(views.presign_upload_confirm("upload-1", ip="127.0.0.1"))
self.assertEqual(response.detail, {"code": "12345", "name": "upload.txt"})
self.assertTrue(FakePresignUploadSession.session.deleted)
self.assertEqual(FakeFileUploadService.created_records[0]["file_size"], 12)
self.assertEqual(
FakeFileUploadService.created_records[0]["file_path"],
"share/data/2026/06/06/upload-1",
)
def test_confirm_rejects_missing_uploaded_direct_file(self):
FakePresignUploadSession.session = FakeSession(mode="direct")
self.storage.exists = False
with self.assertRaises(HTTPException) as error:
asyncio.run(views.presign_upload_confirm("upload-1", ip="127.0.0.1"))
self.assertEqual(error.exception.status_code, 404)
self.assertFalse(FakePresignUploadSession.session.deleted)
self.assertEqual(FakeFileUploadService.created_records, [])
def test_proxy_upload_rejects_size_mismatch_before_saving_file(self):
FakePresignUploadSession.session = FakeSession(mode="proxy", file_size=10)
with self.assertRaises(HTTPException) as error:
asyncio.run(
views.presign_upload_proxy(
"upload-1",
file=FakeUploadFile(size=2048),
ip="127.0.0.1",
)
)
self.assertEqual(error.exception.status_code, 403)
self.assertEqual(self.storage.saved, [])
def test_cancel_direct_session_removes_uploaded_object_when_present(self):
FakePresignUploadSession.session = FakeSession(mode="direct")
self.storage.exists = True
response = asyncio.run(views.presign_upload_cancel("upload-1"))
self.assertEqual(response.detail, {"message": "上传会话已取消"})
self.assertTrue(FakePresignUploadSession.session.deleted)
self.assertEqual(len(self.storage.deleted), 1)
self.assertEqual(self.storage.deleted[0].file_path, "share/data/2026/06/06/upload-1")
self.assertEqual(self.storage.deleted[0].uuid_file_name, "upload.txt")
def test_expired_session_is_deleted_and_rejected(self):
FakePresignUploadSession.session = FakeSession(mode="direct", expired=True)
FakePresignUploadSession.session.expires_at = asyncio.run(get_now()) - timedelta(seconds=1)
with self.assertRaises(HTTPException) as error:
asyncio.run(views.presign_upload_confirm("upload-1", ip="127.0.0.1"))
self.assertEqual(error.exception.status_code, 404)
self.assertTrue(FakePresignUploadSession.session.deleted)