mirror of
https://github.com/vastsa/FileCodeBox.git
synced 2026-11-21 22:47:13 +08:00
272 lines
9.3 KiB
Python
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)
|