Files
FileCodeBox/tests/test_webdav_storage.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

235 lines
8.6 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.
"""WebDAV storage backend coverage against a real in-process WebDAV server.
aioboto3-style mocking cannot fake aiohttp; the backend speaks real HTTP
(HEAD/GET/PUT/DELETE/MKCOL/PROPFIND), so the fixture boots a minimal WebDAV
server over a temp directory and exercises the backend through the wire.
Focus on failure branches: missing objects, merge failures, cleanup scoping,
connection errors.
"""
import hashlib
import io
import shutil
import tempfile
from pathlib import Path
from types import SimpleNamespace
import pytest
from aiohttp import web
from core.errors import StorageError
from core.storage import StoredFile, WebDAVFileStorage
def make_dav_app(root: Path) -> web.Application:
"""Minimal WebDAV server: HEAD/GET/PUT/DELETE/MKCOL/PROPFIND over `root`."""
def _fs_path(request: web.Request) -> Path | None:
rel = request.match_info.get("path", "")
target = (root / rel).resolve()
if not str(target).startswith(str(root)):
return None
return target
async def handler(request: web.Request) -> web.StreamResponse:
target = _fs_path(request)
if target is None:
return web.Response(status=403)
method = request.method
if method == "HEAD":
if target.is_file():
return web.Response(
status=200, headers={"Content-Length": str(target.stat().st_size)}
)
if target.is_dir():
return web.Response(status=200)
return web.Response(status=404)
if method == "GET":
if target.is_file():
return web.FileResponse(target)
return web.Response(status=404)
if method == "PUT":
if target.is_dir():
return web.Response(status=409)
target.parent.mkdir(parents=True, exist_ok=True)
target.write_bytes(await request.read())
return web.Response(status=201)
if method == "MKCOL":
if target.exists():
return web.Response(status=405)
if not target.parent.exists():
return web.Response(status=409)
target.mkdir()
return web.Response(status=201)
if method == "DELETE":
if target.is_file():
target.unlink()
return web.Response(status=204)
if target.is_dir():
shutil.rmtree(target)
return web.Response(status=204)
return web.Response(status=404)
if method == "PROPFIND":
if not target.exists() or not target.is_dir():
return web.Response(status=404)
hrefs = [p.relative_to(root).as_posix() for p in target.iterdir()]
body = "".join(
f"<D:response><D:href>{h}</D:href></D:response>" for h in hrefs
)
xml = f"<D:multistatus>{body}</D:multistatus>"
return web.Response(status=207, text=xml, content_type="application/xml")
return web.Response(status=405)
app = web.Application()
app.router.add_route("*", "/{path:.*}", handler)
return app
@pytest.fixture
async def dav_storage():
from core.settings import settings
from aiohttp.test_utils import TestServer
root = Path(tempfile.mkdtemp(prefix="fcb-dav-"))
app = make_dav_app(root)
server = TestServer(app)
await server.start_server()
endpoint = f"http://127.0.0.1:{server.port}/dav/"
original = dict(settings.user_config)
settings.user_config = {
**original,
"file_storage": "webdav",
"webdav_url": endpoint,
"webdav_username": "user",
"webdav_password": "pass",
}
try:
yield WebDAVFileStorage(), root
finally:
settings.user_config = original
await server.close()
shutil.rmtree(root, ignore_errors=True)
def _stored(key: str) -> StoredFile:
return StoredFile(
file_path=key.rsplit("/", 1)[0], uuid_file_name=key.rsplit("/", 1)[1]
)
def _records(chunks: dict[int, bytes]) -> dict:
return {
i: SimpleNamespace(chunk_hash=hashlib.sha256(d).hexdigest())
for i, d in chunks.items()
}
@pytest.mark.asyncio
class TestWebDAVObjectBasics:
async def test_save_roundtrip_and_exists(self, dav_storage):
storage, _ = dav_storage
await storage.save_file(
io.BytesIO(b"payload"), "share/data/f.bin", "application/octet-stream"
)
assert await storage.file_exists("share/data/f.bin") is True
assert await storage.file_exists("share/data/ghost.bin") is False
async def test_delete_file_and_empty_parent_dirs(self, dav_storage):
storage, _ = dav_storage
await storage.save_file(io.BytesIO(b"payload"), "share/data/2026/01/01/x/f.bin")
await storage.delete_file(_stored("share/data/2026/01/01/x/f.bin"))
assert await storage.file_exists("share/data/2026/01/01/x/f.bin") is False
# 空父目录被逐级清理(file_exists 对目录 HEAD 也是 404)
assert await storage.file_exists("share/data/2026/01/01/x") is False
async def test_delete_missing_file_is_accepted(self, dav_storage):
storage, _ = dav_storage
await storage.delete_file(_stored("share/data/never-existed.bin"))
async def test_get_file_response_roundtrip(self, dav_storage):
storage, _ = dav_storage
payload = b"dav-stream-payload"
await storage.save_file(io.BytesIO(payload), "share/data/s.bin")
download = await storage.get_file_response(_stored("share/data/s.bin"))
assert download.headers["Content-Length"] == str(len(payload))
chunks = [chunk async for chunk in download.stream_factory()]
assert b"".join(chunks) == payload
@pytest.mark.asyncio
class TestWebDAVGetFileResponseFailures:
async def test_missing_object_raises_404_upfront(self, dav_storage):
"""缺失对象前置 404,与 local/S3 语义对齐(不许 200 坏流)。"""
storage, _ = dav_storage
with pytest.raises(StorageError) as exc_info:
await storage.get_file_response(_stored("share/data/ghost.bin"))
assert exc_info.value.status_code == 404
async def test_connection_error_maps_to_503(self, monkeypatch):
from core.settings import settings
original = dict(settings.user_config)
settings.user_config = {
**original,
"webdav_url": "http://127.0.0.1:1/", # 无服务的端口
"webdav_username": "u",
"webdav_password": "p",
}
try:
storage = WebDAVFileStorage()
with pytest.raises(StorageError) as exc_info:
await storage.get_file_response(_stored("share/data/x.bin"))
assert exc_info.value.status_code == 503
finally:
settings.user_config = original
@pytest.mark.asyncio
class TestWebDAVChunkMerge:
async def test_merge_success_and_cleanup(self, dav_storage):
storage, _ = dav_storage
upload_id = "up01"
save_path = "share/data/2026/01/01/up01/merged.bin"
parts = {0: b"AAAA", 1: b"BBBB"}
for i, data in parts.items():
await storage.save_chunk(upload_id, i, data, "ignored", save_path)
_, file_hash = await storage.merge_chunks(
upload_id, 2, 4, save_path, _records(parts)
)
assert file_hash == hashlib.sha256(b"AAAABBBB").hexdigest()
assert await storage.file_exists(save_path) is True
await storage.clean_chunks(upload_id, save_path)
assert (
await storage.file_exists(
f"share/data/2026/01/01/up01/chunks/{upload_id}/0.part"
)
is False
)
async def test_merge_missing_chunk_raises(self, dav_storage):
storage, _ = dav_storage
save_path = "share/data/2026/01/01/up02/merged.bin"
await storage.save_chunk("up02", 1, b"BBBB", "ignored", save_path) # 缺分片 0
with pytest.raises(ValueError, match="分片0"):
await storage.merge_chunks(
"up02", 2, 4, save_path, _records({0: b"AAAA", 1: b"BBBB"})
)
assert await storage.file_exists(save_path) is False
async def test_merge_hash_mismatch_raises(self, dav_storage):
storage, _ = dav_storage
save_path = "share/data/2026/01/01/up03/merged.bin"
await storage.save_chunk("up03", 0, b"AAAA", "ignored", save_path)
bad = {0: SimpleNamespace(chunk_hash="f" * 64)}
with pytest.raises(ValueError, match="哈希不匹配"):
await storage.merge_chunks("up03", 1, 4, save_path, bad)
assert await storage.file_exists(save_path) is False