Files
FileCodeBox/tests/test_admin_read_paths.py
Marrrrrrrrry 57c75a7141 全量修复/补测试+UED改进 (#535)
* fix: constant-time comparison for download tokens (security item 5)

Replace the set-membership key check in /share/download with
hmac.compare_digest over the two valid window tokens; add negative-path
tests (wrong key 403, both windows accepted, foreign-code token 403).

* fix: single source for attachment headers + guard tests (security item 2)

All six Content-Disposition construction sites across the five storage
backends now go through build_attachment_headers; the header is what
neutralizes stored XSS on the same-origin download path. Guard tests
assert every get_file_response uses the builder and no hand-built
disposition reappears.

* fix: reject internal-network endpoints for storage config (security item 7)

s3_endpoint_url/s3_hostname/webdav_url are fetched server-side; with
APP_ENV=production the write entry now enforces http(s) schemes and a
loopback/private/link-local/metadata host blacklist. Development env
stays open for local minio/webdav. Already-stored values are never
re-validated, so existing deployments are unaffected.

* fix: JSON 404 for handler-raised 404s; negative-path test batch

Starlette status-code handlers take precedence over the HTTPException
class handler, so registering the theme index as the 404 handler turned
every HTTPException(404) app-wide into a 200 HTML page (found by the new
negative-path tests). The new not_found_handler serves the theme page
only to browsers (Accept: text/html) and JSON 404 to API clients.

Negative-path batch: download count exhaustion, missing chunk session
404s, expired presign session deletion, admin update_file uniqueness/
existence.

* fix: run container as non-root app user with compat volume chown (security item 3)

Entrypoint starts as root only to fix the data-dir ownership (skipped
when nothing needs changing or when the deployer sets an explicit user),
then drops to uid 10001 via gosu. Verified in-container: uvicorn runs as
app (uid 10001), setup and share round-trip work against a root-owned
volume.

* fix: compare download tokens as bytes (non-ASCII key caused 500)

* test: lock changed-only semantics for endpoint config saves

Integration regression for the background lesson: a stored internal
endpoint must not block unrelated settings saves in production mode;
changing to an internal endpoint (URL or bare-hostname form) is 400.

* fix: resolve-based SSRF check — deny IP shorthands, hex/decimal IPs, DNS maps

Probe found the static blacklist bypassed by glibc shorthands (127.1,
10.1), decimal (2130706433) and hex IP forms, *.localhost, and
loopback-mapping DNS services. Both validators now resolve the host and
re-check every resolved address; hostname tier extracts the host part
correctly for [v6]/host:port/bare-v6 forms. 44 tests.

* test: pin 404 handler dual-branch behavior (browser theme page vs API JSON)

* fix: write back normalized endpoint values; hostname dev-gate test

* test: header-injection negative paths for attachment disposition

* fix: S3 merge buffers parts to >=5MiB; missing object 404 upfront

- S3 multipart rejects parts <5MiB (EntityTooSmall) except the last; chunk
  size is client-controlled (commonly 2-4MB) so multi-chunk merges always
  failed with 500. Merge now buffers chunks into >=5MiB parts (memory
  bound: 5MB + one chunk).
- get_file_response: a 404 head_object now raises StorageError(404)
  upfront instead of signing a doomed presigned URL and failing mid-stream
  (aligns with local backend semantics from the M2 behavior unification).

* test: S3 backend coverage via in-process moto server (13 cases)

mock_aws cannot intercept aioboto3's aiohttp stack, so tests run against
a real in-process ThreadedMotoServer endpoint. Covers roundtrips, missing
object 404, merge failure modes (missing chunk / hash mismatch -> abort,
no leftover object), cleanup scoping, presign shapes, proxy dispatch.
Also adds moto[s3,server] to the dev group and CI.

* fix: WebDAV missing object 404 upfront; connection errors map to 503

HEAD 404 was silently swallowed (signed a 200 bad stream that failed
mid-download, same family as the S3 bug), and HEAD connection errors were
also swallowed so the 503 mapping never fired. Both now surface properly;
the aiohttp session is reclaimed on pre-stream exception paths.

* test: WebDAV backend coverage via in-process WebDAV server (9 cases)

Real HTTP (HEAD/GET/PUT/DELETE/MKCOL/PROPFIND) against a minimal aiohttp
WebDAV server over a temp dir: roundtrips, missing object 404, connection
error 503, delete with empty-parent cleanup, merge failure modes, chunk
cleanup scoping.

* fix: OneDrive missing object maps to 404 upfront; OpenDAL behavior pinned

OneDrive get_file_response translated graph itemNotFound into the outer
503 catch-all; now raises StorageError(404) like local/S3/WebDAV.
OpenDAL already mapped missing objects to 404 via its outer catch —
pinned with fake-operator tests (SDK not in runtime deps, instances built
via __new__). Also tightens the S3 presign URL assertion.

* test: admin write-path coverage (batch/single delete, batch update, policy actions)

13 negative-path cases for the previously untested data-modifying admin
endpoints: mixed-id aggregation with duplicates and missing records,
empty-list rejections, clear_expired_at permanence semantics, policy
action boundaries (zero limit 400, unknown action 400, missing 404),
and the DoesNotExist->404 mapping pinned for single delete.

* test: admin read-path and view-preset CRUD coverage (22 cases)

Detail/metadata/preview/admin-download/activities/local-lists+delete/
verify: missing-record 404s, note/tag truncation limits, preview max_chars
truncation, activity filtering and the 80-event clamp, local path
traversal rejection. Presets: update-vs-create by id, name truncation,
filter normalization clamps, 24-preset cap, delete-missing 404.

* refactor: move auth primitives to apps/base/auth, kill base->admin dep

JWT create/verify, bearer extraction and the share-upload gate move to
apps.base.auth (consumed by both surfaces); admin.dependencies keeps
admin session gating and service providers, re-exporting the primitives
for import-path compatibility. base.views no longer imports from
apps.admin — the last cross-app reverse dependency is gone.

* refactor: split admin services god-module (ConfigService/LocalFile out)

apps/admin/services.py (1697 lines) becomes FileService (~1200 lines) +
a compatibility facade re-exporting ConfigService, LocalFileService,
LocalFileClass and keyvalue_write_lock from their new homes
(config_service.py holds the D5 KeyValue lock; one-way imports, no
cycle). test_admin_security patch targets follow ConfigService to its
new module. Behavior unchanged; 247 tests green.

* fix: size-less uploads no longer crash (upstream seek bug)

validate_file_size's size-None branch called UploadFile.seek(0, 2),
which raises TypeError (UploadFile.seek takes one arg); the underlying
SpooledTemporaryFile.seek is sync, so awaiting it also fails. Use the
underlying file object with sync seek(0, SEEK_END). Surface discovered
by the mypy pilot run; regression test covers the size-None branch.

* chore: bump direct deps (patch/minor)

fastapi 0.139.2->0.141.1, pydantic 2.12.5->2.13.5, uvicorn 0.51.0->0.53.0,
aiohttp 3.14.2->3.14.3; lockfile regenerated. tortoise-orm 0.x->1.x major
deliberately deferred pending API-change review.

* ci: gradual mypy adoption via baseline ratchet

scripts/mypy_ratchet.py compares mypy output against
scripts/mypy-baseline.txt (line numbers stripped for edit stability):
new type errors fail CI, fixes are folded back via --regenerate.
Baseline starts at 30 known errors; the seek bug found in the pilot was
fixed before baselining. mypy joins the dev group and CI.

* fix: migrate WebDAV auth off aiohttp.BasicAuth (deprecated in 4.0)

Dependency-upgrade probe on aiohttp 3.14.3 surfaced the BasicAuth
deprecation; switch to aiohttp.encode_basic_auth() headers so the
aiohttp 4.0 upgrade does not break the WebDAV backend.

* chore: drop dead code (WebDAV _instance stub, unused LocalFileClass.write)

* test: file-validation negative paths (13 cases)

Magic-bytes spoofing (text-as-png, exe-as-pdf, mp4/webp box detection),
whitelist rule semantics (star/image-wildcard/content mismatch), chunk-0
header validation parity, and end-to-end UploadFile rejection.

* test: migration runner coverage (5 cases)

Full chain executes 001-007 in filename order and registers; rerun is
idempotent; pre-registered entries are skipped (DDL not re-executed);
the resulting schema matches deployment; a failing migration propagates
and is not registered. Uses a fresh :memory: DB without
generate_schemas so the migrations themselves build the schema (the
real deployment path).

* refactor: split core/storage.py into a package (per-backend modules)

core/storage.py (1400+ lines, six backends) becomes core/storage/ with
_base.py (data contracts, interface, shared header builder), and
local/s3/onedrive/opendal/webdav modules. The package __init__
re-exports the full historical public surface; test patch targets move
to the precise backend modules (core.storage.local.data_root etc.) and
the attachment guard scans the package. Import-only change; 264 tests
green. Storage-layer DI deferred: current tests construct instances
against patched settings, so the added surface isn't justified yet.

* refactor: TypedDict for IPRateLimit records

The rate-limit ledger mixed int and datetime under a loose Union typing,
producing 5 mypy noise errors. A TypedDict gives precise per-key types;
setdefault replaces the get-then-assign pattern. One mypy baseline error
family resolved; 264 tests green.

* chore: tighten mypy baseline after IPRateLimit TypedDict

* refactor: resolve all 26 baseline mypy errors; precise test assertions

Per-error treatment (no bulk script): honest annotations for
StoredDownload (Path/bytes/Callable), KeyValue.value (Any for JSONField),
dict[str, Any] for form/config dicts; signature split in create_token;
str() normalization in config int(); platform/type-ignore only where the
checker cannot follow (msvcrt, FastAPI Request injection). Baseline file
and ratchet compare now redundant at zero errors but kept as the guard
against regressions.

Tests: assertions tightened to status_code == 403 with HTTPException
raises; _create_share explicit parameters replace **extra passthrough;
seek-fix pointer-reset assertion persisted.
2026-09-20 03:01:08 +09:00

260 lines
9.8 KiB
Python
Raw Permalink Blame History

This file contains ambiguous Unicode characters
This file contains Unicode characters that might be confused with other characters. If you think that this is intentional, you can safely ignore this warning. Use the Escape button to reveal them.
"""Admin read-path coverage: detail, metadata, preview, admin download,
activities filtering, local file lists/delete, and verify.
These endpoints previously had zero automated coverage. Negative paths
first: missing records, truncation limits, wrong-type rejections.
"""
import pytest
from tests.test_admin_write_paths import _create_share, _login
@pytest.mark.asyncio
class TestFileDetail:
async def test_detail_returns_policy_storage_metadata(self, initialized_client):
token = await _login(initialized_client)
file_id = await _create_share("dt-exist")
response = await initialized_client.get(
"/admin/file/detail",
params={"id": file_id},
headers={"Authorization": f"Bearer {token}"},
)
assert response.status_code == 200, response.text
detail = response.json()["detail"]
assert detail["code"] == "dt-exist"
assert detail["is_text"] is True
assert {"policy", "storage", "metadata", "timeline"} <= set(detail.keys())
async def test_detail_missing_file_404(self, initialized_client):
token = await _login(initialized_client)
for method, kwargs in (
("get", {"params": {"id": 987658}}),
("post", {"json": {"id": 987658}}),
):
response = await initialized_client.request(
method,
"/admin/file/detail",
headers={"Authorization": f"Bearer {token}"},
**kwargs,
)
assert response.status_code == 404, method
@pytest.mark.asyncio
class TestFileMetadata:
async def test_note_and_tags_roundtrip_with_truncation(self, initialized_client):
token = await _login(initialized_client)
file_id = await _create_share("md-round")
# note 超长被截断到 2000;tags 超 12 个被截、单个超 24 字符被截、去重
long_note = "n" * 3000
tags = [f"tag{i}" for i in range(15)] + ["x" * 30, "dup", "dup"]
response = await initialized_client.post(
"/admin/file/metadata",
json={"id": file_id, "note": long_note, "tags": tags},
headers={"Authorization": f"Bearer {token}"},
)
assert response.status_code == 200, response.text
detail = (
await initialized_client.get(
"/admin/file/detail",
params={"id": file_id},
headers={"Authorization": f"Bearer {token}"},
)
).json()["detail"]
metadata = detail["metadata"]
assert len(metadata["note"]) == 2000
assert len(metadata["tags"]) == 12
assert all(len(tag) <= 24 for tag in metadata["tags"])
assert metadata["updated_at"] is not None
async def test_metadata_missing_file_404(self, initialized_client):
token = await _login(initialized_client)
response = await initialized_client.post(
"/admin/file/metadata",
json={"id": 987659, "note": "x"},
headers={"Authorization": f"Bearer {token}"},
)
assert response.status_code == 404
@pytest.mark.asyncio
class TestFilePreview:
async def test_text_preview_truncates_with_max_chars(self, initialized_client):
token = await _login(initialized_client)
file_id = await _create_share("pv-trunc", text="abcdefgh" * 10)
response = await initialized_client.get(
"/admin/file/preview",
params={"id": file_id, "max_chars": 10},
headers={"Authorization": f"Bearer {token}"},
)
assert response.status_code == 200, response.text
detail = response.json()["detail"]
assert detail["content"] == "abcdefghab"
assert detail["truncated"] is True
assert detail["preview_length"] == 10
assert detail["max_chars"] == 10
async def test_preview_non_text_rejected_400(self, initialized_client):
token = await _login(initialized_client)
from apps.base.models import FileCodes
file_id = (
await FileCodes.create(
code="pv-file", prefix="doc", suffix=".bin", size=1
)
).id
response = await initialized_client.get(
"/admin/file/preview",
params={"id": file_id},
headers={"Authorization": f"Bearer {token}"},
)
assert response.status_code == 400
async def test_preview_missing_file_404(self, initialized_client):
token = await _login(initialized_client)
response = await initialized_client.get(
"/admin/file/preview",
params={"id": 987660},
headers={"Authorization": f"Bearer {token}"},
)
assert response.status_code == 404
@pytest.mark.asyncio
class TestAdminDownload:
async def test_text_share_download_returns_content(self, initialized_client):
token = await _login(initialized_client)
file_id = await _create_share("dl-text", text="admin-download-body")
response = await initialized_client.get(
"/admin/file/download",
params={"id": file_id},
headers={"Authorization": f"Bearer {token}"},
)
assert response.status_code == 200
assert b"admin-download-body" in response.content
async def test_missing_file_download_404(self, initialized_client):
token = await _login(initialized_client)
response = await initialized_client.get(
"/admin/file/download",
params={"id": 987661},
headers={"Authorization": f"Bearer {token}"},
)
assert response.status_code == 404
@pytest.mark.asyncio
class TestActivities:
async def test_recorded_action_is_listed_and_filtered(self, initialized_client):
"""删一个文件产生活动事件;action 过滤必须生效。"""
token = await _login(initialized_client)
file_id = await _create_share("act-del")
await initialized_client.request(
"DELETE",
"/admin/file/delete",
json={"id": file_id},
headers={"Authorization": f"Bearer {token}"},
)
listed = await initialized_client.get(
"/admin/activities",
params={"action": "file.delete"},
headers={"Authorization": f"Bearer {token}"},
)
assert listed.status_code == 200
activities = listed.json()["detail"]["activities"]
assert any(
a["action"] == "file.delete" and a["target_id"] == file_id
for a in activities
)
other = await initialized_client.get(
"/admin/activities",
params={"action": "nonexistent.action"},
headers={"Authorization": f"Bearer {token}"},
)
assert other.json()["detail"]["activities"] == []
async def test_limit_upper_bound_clamped_to_80(self, initialized_client):
token = await _login(initialized_client)
response = await initialized_client.get(
"/admin/activities",
params={"limit": 5000},
headers={"Authorization": f"Bearer {token}"},
)
assert response.status_code == 200
assert response.json()["detail"]["limit"] == 80
@pytest.mark.asyncio
class TestLocalFileEndpoints:
async def test_lists_and_delete_roundtrip(self, initialized_client):
"""data/local 列表与删除(走端点层;存储层语义由 WebDAV 轮覆盖)。"""
import shutil
from core.settings import data_root
token = await _login(initialized_client)
local_dir = data_root / "local" / "e2e-probe"
local_dir.mkdir(parents=True, exist_ok=True)
try:
(local_dir / "probe.txt").write_bytes(b"local-probe")
listed = await initialized_client.get(
"/admin/local/lists",
params={"path": "e2e-probe"},
headers={"Authorization": f"Bearer {token}"},
)
assert listed.status_code == 200, listed.text
items = listed.json()["detail"]["items"]
assert any(item["name"] == "probe.txt" for item in items)
deleted = await initialized_client.request(
"DELETE",
"/admin/local/delete",
json={"filename": "e2e-probe/probe.txt"},
headers={"Authorization": f"Bearer {token}"},
)
assert deleted.status_code == 200
assert not (local_dir / "probe.txt").exists()
finally:
shutil.rmtree(data_root / "local" / "e2e-probe", ignore_errors=True)
async def test_local_delete_traversal_rejected(self, initialized_client):
token = await _login(initialized_client)
response = await initialized_client.request(
"DELETE",
"/admin/local/delete",
json={"filename": "../../filecodebox.db"},
headers={"Authorization": f"Bearer {token}"},
)
assert response.status_code == 400
async def test_local_delete_missing_404(self, initialized_client):
token = await _login(initialized_client)
response = await initialized_client.request(
"DELETE",
"/admin/local/delete",
json={"filename": "ghost.txt"},
headers={"Authorization": f"Bearer {token}"},
)
assert response.status_code == 404
@pytest.mark.asyncio
class TestVerify:
async def test_valid_token_passes(self, initialized_client):
token = await _login(initialized_client)
response = await initialized_client.get(
"/admin/verify", headers={"Authorization": f"Bearer {token}"}
)
assert response.status_code == 200
async def test_garbage_token_rejected_401(self, initialized_client):
response = await initialized_client.get(
"/admin/verify", headers={"Authorization": "Bearer garbage.token.here"}
)
assert response.status_code == 401