mirror of
https://github.com/vastsa/FileCodeBox.git
synced 2026-11-20 13:29:56 +08:00
- 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
215 lines
8.4 KiB
Python
215 lines
8.4 KiB
Python
"""End-to-end integration tests over the real ASGI stack (httpx).
|
|
|
|
Covers the core user journey that legacy unittest tests skip by calling view
|
|
functions directly: routing, auth dependencies, rate-limit middleware, and
|
|
storage I/O in one chain.
|
|
|
|
Route note: /share and /chunk routes are registered with trailing slashes and
|
|
rely on redirect_slashes for the bare form; tests use the canonical slash form.
|
|
"""
|
|
import io
|
|
|
|
import httpx
|
|
import pytest
|
|
|
|
from apps.base.models import KeyValue
|
|
from core.settings import settings
|
|
from tests.conftest import TEST_ADMIN_PASSWORD
|
|
|
|
|
|
async def _login(client: httpx.AsyncClient) -> str:
|
|
response = await client.post(
|
|
"/admin/login",
|
|
json={"username": "admin", "password": TEST_ADMIN_PASSWORD},
|
|
)
|
|
assert response.status_code == 200, response.text
|
|
return response.json()["detail"]["token"]
|
|
|
|
|
|
async def _set_db_config(key: str, value):
|
|
"""Persist a config change into the settings KeyValue row.
|
|
|
|
The per-request middleware refreshes settings from the DB, so tests that
|
|
need a config to stick must write it there (mutating settings.<attr> alone
|
|
gets overwritten on the next request).
|
|
"""
|
|
record = await KeyValue.filter(key="settings").first()
|
|
config = dict(record.value or {})
|
|
config[key] = value
|
|
record.value = config
|
|
await record.save()
|
|
settings.user_config = config
|
|
|
|
|
|
async def _share_text(client, text="hello integration", expire_value=1, expire_style="day"):
|
|
response = await client.post(
|
|
"/share/text",
|
|
data={
|
|
"text": text,
|
|
"expire_value": str(expire_value),
|
|
"expire_style": expire_style,
|
|
},
|
|
)
|
|
assert response.status_code == 200, response.text
|
|
return response.json()["detail"]["code"]
|
|
|
|
|
|
async def _share_file(client, name, payload, expire_style="day"):
|
|
response = await client.post(
|
|
"/share/file",
|
|
data={"expire_value": "1", "expire_style": expire_style},
|
|
files={"file": (name, io.BytesIO(payload), "application/octet-stream")},
|
|
)
|
|
assert response.status_code == 200, response.text
|
|
return response.json()["detail"]["code"]
|
|
|
|
|
|
async def _select(client, code):
|
|
response = await client.post("/share/select", json={"code": code})
|
|
assert response.status_code == 200, response.text
|
|
return response.json()
|
|
|
|
|
|
async def _download(client, download_url, headers=None, expected=200):
|
|
response = await client.get(download_url, headers=headers or {})
|
|
assert response.status_code == expected, response.text
|
|
return response
|
|
|
|
|
|
@pytest.mark.usefixtures("initialized_client")
|
|
class TestFileShareJourney:
|
|
async def test_upload_select_download_roundtrip(self, client):
|
|
payload = bytes(range(256)) * 64
|
|
code = await _share_file(client, "trip.bin", payload)
|
|
detail = (await _select(client, code))["detail"]
|
|
response = await _download(client, detail["download_url"])
|
|
assert response.headers["content-type"].startswith("application/octet-stream")
|
|
assert "attachment" in response.headers["content-disposition"]
|
|
assert response.content == payload
|
|
|
|
async def test_range_download_returns_206_slices(self, client):
|
|
payload = bytes(range(256)) * 64
|
|
code = await _share_file(client, "range.bin", payload)
|
|
detail = (await _select(client, code))["detail"]
|
|
url = detail["download_url"]
|
|
|
|
head = await _download(client, url, headers={"Range": "bytes=0-99"}, expected=206)
|
|
assert head.content == payload[:100]
|
|
assert head.headers["content-range"] == f"bytes 0-99/{len(payload)}"
|
|
|
|
tail = await _download(client, url, headers={"Range": f"bytes=100-{len(payload)-1}"}, expected=206)
|
|
assert tail.content == payload[100:]
|
|
|
|
out_of_range = await client.get(url, headers={"Range": "bytes=999999999-"})
|
|
assert out_of_range.status_code == 416
|
|
|
|
async def test_text_share_roundtrip(self, client):
|
|
code = await _share_text(client, "hello integration")
|
|
detail = (await _select(client, code))["detail"]
|
|
assert detail["text"] == "hello integration"
|
|
|
|
async def test_count_limited_code_fails_after_exhaustion(self, client):
|
|
code = await _share_text(client, "one-shot", expire_style="count", expire_value=1)
|
|
await _select(client, code) # consumes the single allowed use
|
|
exhausted = await _select(client, code)
|
|
assert exhausted["code"] == 404
|
|
|
|
|
|
@pytest.mark.usefixtures("initialized_client")
|
|
class TestChunkUploadJourney:
|
|
CHUNK_SIZE = 64
|
|
|
|
async def _init_session(self, client, payloads, name="chunk.bin"):
|
|
file_size = sum(len(p) for p in payloads)
|
|
response = await client.post(
|
|
"/chunk/upload/init/",
|
|
json={
|
|
"file_name": name,
|
|
"chunk_size": self.CHUNK_SIZE,
|
|
"file_size": file_size,
|
|
"file_hash": "0" * 64,
|
|
},
|
|
)
|
|
assert response.status_code == 200, response.text
|
|
return response.json()["detail"]["upload_id"]
|
|
|
|
async def _upload_chunk(self, client, upload_id, index, payload):
|
|
response = await client.post(
|
|
f"/chunk/upload/chunk/{upload_id}/{index}",
|
|
files={"chunk": (f"part{index}", io.BytesIO(payload), "application/octet-stream")},
|
|
)
|
|
return response
|
|
|
|
async def test_full_chunk_upload_merge_and_download(self, client):
|
|
payloads = [bytes([65 + i]) * self.CHUNK_SIZE for i in range(3)]
|
|
upload_id = await self._init_session(client, payloads)
|
|
|
|
for index, chunk in enumerate(payloads):
|
|
response = await self._upload_chunk(client, upload_id, index, chunk)
|
|
assert response.status_code == 200, response.text
|
|
|
|
response = await client.post(
|
|
f"/chunk/upload/complete/{upload_id}",
|
|
data={"expire_value": "1", "expire_style": "day"},
|
|
)
|
|
assert response.status_code == 200, response.text
|
|
code = response.json()["detail"]["code"]
|
|
|
|
detail = (await _select(client, code))["detail"]
|
|
response = await _download(client, detail["download_url"])
|
|
assert response.content == b"".join(payloads)
|
|
|
|
async def test_chunk_oversize_rejected(self, client):
|
|
payloads = [b"x" * (self.CHUNK_SIZE + 1)]
|
|
upload_id = await self._init_session(client, payloads)
|
|
response = await self._upload_chunk(client, upload_id, 0, payloads[0])
|
|
assert response.status_code == 400, response.text
|
|
|
|
async def test_invalid_chunk_index_rejected(self, client):
|
|
payloads = [b"x" * self.CHUNK_SIZE]
|
|
upload_id = await self._init_session(client, payloads)
|
|
response = await self._upload_chunk(client, upload_id, 99, payloads[0])
|
|
assert response.status_code == 400, response.text
|
|
|
|
async def test_cancel_upload_cleans_session(self, client):
|
|
payloads = [b"x" * self.CHUNK_SIZE, b"y" * self.CHUNK_SIZE]
|
|
upload_id = await self._init_session(client, payloads)
|
|
|
|
response = await client.delete(f"/chunk/upload/{upload_id}")
|
|
assert response.status_code == 200, response.text
|
|
|
|
# Session and chunk records must be gone from the DB. (Asserting on the
|
|
# status endpoint instead would depend on the 404 handler, which needs
|
|
# a built theme to render in bare checkouts.)
|
|
from apps.base.models import UploadChunk
|
|
|
|
assert not await UploadChunk.filter(upload_id=upload_id).exists()
|
|
|
|
|
|
@pytest.mark.usefixtures("initialized_client")
|
|
class TestUploadAuth:
|
|
async def test_guest_upload_allowed_when_open_upload_on(self, client):
|
|
await _set_db_config("open_upload", 1)
|
|
code = await _share_text(client, "guest ok")
|
|
assert code
|
|
|
|
async def test_upload_requires_login_when_guest_upload_off(self, client):
|
|
await _set_db_config("open_upload", 0)
|
|
response = await client.post(
|
|
"/share/text",
|
|
data={"text": "no guest", "expire_value": "1", "expire_style": "day"},
|
|
)
|
|
assert response.status_code == 403, response.text
|
|
|
|
token = await _login(client)
|
|
response = await client.post(
|
|
"/share/text",
|
|
data={"text": "admin ok", "expire_value": "1", "expire_style": "day"},
|
|
headers={"Authorization": f"Bearer {token}"},
|
|
)
|
|
assert response.status_code == 200, response.text
|
|
|
|
async def test_admin_endpoints_reject_missing_token(self, client):
|
|
response = await client.get("/admin/file/list/")
|
|
assert response.status_code == 401, response.text
|