Files
FileCodeBox/tests/test_issue_482_share_usage.py
Marrrrrrrrry 5121db6edc feat: rename all config keys to snake_case with DB migration 007
- 20 camelCase keys (uploadSize, expireStyle, openUpload, ...) renamed across
  DEFAULT_CONFIG, settings accessors, setup form fields, and ConfigService
- migrations_007 renames keys inside the existing settings KeyValue row,
  preserving all values for existing deployments
- schema guard meta-test keeps future keys declared
2026-09-09 18:09:19 +08:00

206 lines
7.2 KiB
Python

import asyncio
import datetime
import unittest
from unittest.mock import patch
from apps.base.models import FileCodes
from apps.base import views
from core.storage import StoredDownload
from tests.helpers import close_db, init_memory_db
from core.settings import DEFAULT_CONFIG, settings
from core.utils import get_now, get_select_token
from apps.base.setup_wizard import build_setup_page, parse_setup_options
class FakeStorage:
direct_url_calls = 0
async def get_file_url(self, file_code):
self.direct_url_calls += 1
return "https://storage.example/reusable-url"
async def get_file_response(self, file_code):
return StoredDownload(
filename=f"{file_code.prefix}{file_code.suffix}",
headers={},
content=f"downloaded:{file_code.code}".encode(),
)
class FakeRateLimit:
def __init__(self):
self.seen_ips = []
def add_ip(self, ip):
self.seen_ips.append(ip)
class ShareUsageSecurityTests(unittest.TestCase):
def test_new_installations_default_to_secret_codes(self):
self.assertEqual(DEFAULT_CONFIG["code_generate_type"], "secret")
self.assertEqual(
parse_setup_options({"expire_style": ["day"]})["code_generate_type"],
"secret",
)
self.assertIn('<option value="secret" selected>', build_setup_page())
def test_atomic_usage_download_and_metadata_limits(self):
asyncio.run(self._run_scenario())
async def _run_scenario(self):
original_config = dict(settings.user_config)
original_metadata_limit = views.ip_limit["metadata"]
settings.file_storage = "local"
settings.jwt_secret = "test-download-secret"
await init_memory_db()
try:
await self._assert_count_consumption_is_atomic()
await self._assert_time_expiration_and_usage_are_atomic()
await self._assert_download_url_is_single_use()
await self._assert_text_share_downloads_as_txt()
await self._assert_limited_files_do_not_expose_direct_urls()
await self._assert_metadata_counts_all_attempts()
finally:
views.ip_limit["metadata"] = original_metadata_limit
settings.user_config = original_config
await close_db()
async def _assert_count_consumption_is_atomic(self):
record = await FileCodes.create(
code="atomic",
prefix="atomic",
suffix=".txt",
expired_count=1,
expired_at=await get_now() + datetime.timedelta(days=1),
)
stale_copies = await asyncio.gather(
*(FileCodes.get(id=record.id) for _ in range(20))
)
consumed = await asyncio.gather(
*(views.consume_file_usage(item) for item in stale_copies)
)
await record.refresh_from_db()
self.assertEqual(sum(consumed), 1)
self.assertEqual(record.expired_count, 0)
self.assertEqual(record.used_count, 1)
async def _assert_time_expiration_and_usage_are_atomic(self):
valid = await FileCodes.create(
code="time-valid",
text="valid",
expired_count=-1,
expired_at=await get_now() + datetime.timedelta(minutes=5),
)
expired = await FileCodes.create(
code="time-expired",
text="expired",
expired_count=-1,
expired_at=await get_now() - datetime.timedelta(seconds=1),
)
valid_copies = await asyncio.gather(
*(FileCodes.get(id=valid.id) for _ in range(20))
)
consumed = await asyncio.gather(
*(views.consume_file_usage(item) for item in valid_copies)
)
self.assertTrue(all(consumed))
self.assertFalse(await views.consume_file_usage(expired))
await valid.refresh_from_db()
await expired.refresh_from_db()
self.assertEqual(valid.expired_count, -1)
self.assertEqual(valid.used_count, 20)
self.assertEqual(expired.used_count, 0)
async def _assert_download_url_is_single_use(self):
record = await FileCodes.create(
code="single-use",
prefix="report",
suffix=".pdf",
expired_count=1,
expired_at=await get_now() + datetime.timedelta(days=1),
)
key = await get_select_token(record.code)
with patch.dict(views.storages, {"local": FakeStorage}):
selected = await views.select_file(
data=views.SelectFileModel(code=record.code), ip="127.0.0.1"
)
await record.refresh_from_db()
self.assertEqual(selected.detail["expired_count"], 1)
self.assertEqual(record.expired_count, 1)
self.assertEqual(record.used_count, 0)
first = await views.download_file(key=key, code=record.code, ip="127.0.0.1")
second = await views.download_file(key=key, code=record.code, ip="127.0.0.1")
self.assertEqual(first.body, b"downloaded:" + record.code.encode())
self.assertEqual(second.code, 404)
await record.refresh_from_db()
self.assertEqual(record.expired_count, 0)
self.assertEqual(record.used_count, 1)
async def _assert_text_share_downloads_as_txt(self):
record = await FileCodes.create(
code="text-download",
prefix="TAG",
text="hello, 文本直链",
expired_count=-1,
expired_at=None,
)
with patch.dict(views.storages, {"local": FakeStorage}):
response = await views.get_code_file(
code=record.code, ip="127.0.0.1"
)
self.assertEqual(response.status_code, 200)
self.assertEqual(response.body.decode("utf-8"), record.text)
self.assertEqual(response.media_type, "text/plain")
self.assertEqual(
response.headers["content-disposition"],
"attachment; filename*=UTF-8''TAG.txt",
)
await record.refresh_from_db()
self.assertEqual(record.used_count, 1)
async def _assert_limited_files_do_not_expose_direct_urls(self):
record = await FileCodes.create(
code="proxy-only",
prefix="archive",
suffix=".zip",
expired_count=2,
expired_at=await get_now() + datetime.timedelta(days=1),
)
storage = FakeStorage()
detail = await views.build_select_detail(record, storage)
self.assertTrue(detail["download_url"].startswith("/share/download?"))
self.assertEqual(storage.direct_url_calls, 0)
async def _assert_metadata_counts_all_attempts(self):
await FileCodes.create(
code="metadata",
text="hello",
expired_count=-1,
expired_at=None,
)
limiter = FakeRateLimit()
views.ip_limit["metadata"] = limiter
success = await views.get_file_metadata(code="metadata", ip="192.0.2.1")
missing = await views.get_file_metadata(code="missing", ip="192.0.2.1")
self.assertEqual(success.code, 200)
self.assertEqual(missing.code, 404)
self.assertEqual(limiter.seen_ips, ["192.0.2.1", "192.0.2.1"])
if __name__ == "__main__":
unittest.main()