from __future__ import annotations import tempfile from pathlib import Path from unittest import TestCase from fastapi import APIRouter, FastAPI from fastapi.testclient import TestClient from sqlalchemy import create_engine from sqlalchemy.orm import sessionmaker from sakura_cloud.api.deps import AdminUser from sakura_cloud.api.v1.router import api_router from sakura_cloud.core.config import settings from sakura_cloud.core.safety import is_allowed_external_url from sakura_cloud.core.security import create_access_token from sakura_cloud.db.base import Base from sakura_cloud.db.session import get_db from sakura_cloud.models import Artwork, CreatorFollow, FileBlob, Novel, User, UserFile from sakura_cloud.models.user import UserRole class SakuraCloudSecurityTest(TestCase): def setUp(self) -> None: self.temp_dir = tempfile.TemporaryDirectory() self.root = Path(self.temp_dir.name) self.db_path = self.root / "cloud.db" self.engine = create_engine(f"sqlite:///{self.db_path}", connect_args={"check_same_thread": False}) self.SessionLocal = sessionmaker(bind=self.engine, autoflush=False, autocommit=False) Base.metadata.create_all(self.engine) self.old_storage_root = settings.storage_root self.old_max_upload_size_mb = settings.max_upload_size_mb settings.storage_root = str(self.root / "storage") settings.max_upload_size_mb = 1 admin_router = APIRouter() @admin_router.get("/admin/probe") def admin_probe(_: AdminUser) -> dict[str, bool]: return {"ok": True} self.app = FastAPI() self.app.include_router(api_router, prefix=settings.api_prefix) self.app.include_router(admin_router, prefix=settings.api_prefix) self.app.dependency_overrides[get_db] = self._override_db self.client = TestClient(self.app) self.user_a_id = "user-a" self.user_b_id = "user-b" self.admin_id = "admin" self._seed_data() self.auth_a = {"Authorization": f"Bearer {create_access_token(self.user_a_id)}"} self.auth_b = {"Authorization": f"Bearer {create_access_token(self.user_b_id)}"} self.auth_admin = {"Authorization": f"Bearer {create_access_token(self.admin_id)}"} def tearDown(self) -> None: self.client.close() self.engine.dispose() settings.storage_root = self.old_storage_root settings.max_upload_size_mb = self.old_max_upload_size_mb self.temp_dir.cleanup() def _override_db(self): db = self.SessionLocal() try: yield db finally: db.close() def _seed_data(self) -> None: storage_file = self.root / "b-file.txt" storage_file.write_text("secret", encoding="utf-8") with self.SessionLocal() as db: user_a = User( id=self.user_a_id, username="alice", email="alice@example.test", password_hash="unused", role=UserRole.USER, ) user_b = User( id=self.user_b_id, username="bob", email="bob@example.test", password_hash="unused", role=UserRole.USER, ) admin = User( id=self.admin_id, username="admin", email="admin@example.test", password_hash="unused", role=UserRole.ADMIN, ) blob = FileBlob( sha256="b" * 64, storage_path=str(storage_file), file_size=storage_file.stat().st_size, mime_type="text/plain", ) user_file = UserFile(id="file-b", user_id=self.user_b_id, file_sha256=blob.sha256, original_name="b-file.txt") artwork = Artwork( id="art-b", user_id=self.user_b_id, file_id=user_file.id, source_platform="pixiv", content_type="illust", title="bob artwork", file_path=str(storage_file), file_size=storage_file.stat().st_size, tags=[], artwork_metadata={}, ) novel = Novel( id="novel-b", user_id=self.user_b_id, file_id=user_file.id, source_platform="pixiv", title="bob novel", file_path=str(storage_file), file_size=storage_file.stat().st_size, tags=[], ) series_chapter = Novel( id="novel-series-a", user_id=self.user_a_id, source_platform="biquge", title="sakura series", series_id="series-a", series_title="Sakura Series", chapter_title="Chapter One", chapter_order=1, file_path=str(storage_file), file_size=storage_file.stat().st_size, tags=[], ) follow = CreatorFollow( id="follow-b", user_id=self.user_b_id, platform="pixiv", creator_id="creator-b", creator_name="Bob Creator", enabled=True, metadata_json={}, ) db.add_all([user_a, user_b, admin, blob, user_file, artwork, novel, series_chapter, follow]) db.commit() def test_protected_resource_groups_return_401_without_login(self) -> None: cases = [ ("GET", "/api/v1/gallery"), ("GET", "/api/v1/gallery/feed"), ("GET", "/api/v1/gallery/stat"), ("POST", "/api/v1/gallery"), ("GET", "/api/v1/novels"), ("GET", "/api/v1/novels/recent"), ("GET", "/api/v1/files/file-b/content"), ("POST", "/api/v1/upload/init"), ("GET", "/api/v1/upload/status/unknown"), ("GET", "/api/v1/follows"), ("POST", "/api/v1/follows"), ("POST", "/api/v1/follows/bulk-upsert"), ("GET", "/api/v1/follows/alerts"), ("GET", "/api/v1/push/devices"), ("POST", "/api/v1/push/register-token"), ("POST", "/api/v1/push/unregister-token"), ] for method, path in cases: with self.subTest(method=method, path=path): response = self.client.request(method, path, json={}) self.assertEqual(response.status_code, 401) def test_user_a_cannot_access_user_b_gallery_novel_file_or_follow_data(self) -> None: gallery = self.client.get("/api/v1/gallery", headers=self.auth_a) self.assertEqual(gallery.status_code, 200) self.assertEqual(gallery.json()["data"]["items"], []) self.assertEqual(self.client.get("/api/v1/gallery/art-b", headers=self.auth_a).status_code, 404) novels = self.client.get("/api/v1/novels", headers=self.auth_a) self.assertEqual(novels.status_code, 200) self.assertNotIn("novel-b", {item["id"] for item in novels.json()["data"]["items"]}) self.assertEqual(self.client.get("/api/v1/novels/novel-b", headers=self.auth_a).status_code, 404) self.assertEqual(self.client.get("/api/v1/novels/novel-b/content", headers=self.auth_a).status_code, 404) self.assertEqual(self.client.get("/api/v1/files/file-b/content", headers=self.auth_a).status_code, 404) self.assertEqual(self.client.get("/api/v1/files/file-b/thumbnail", headers=self.auth_a).status_code, 404) follows = self.client.get("/api/v1/follows", headers=self.auth_a) self.assertEqual(follows.status_code, 200) self.assertEqual(follows.json()["data"], []) self.assertEqual(self.client.delete("/api/v1/follows/follow-b", headers=self.auth_a).status_code, 404) self.assertEqual(self.client.get("/api/v1/gallery/art-b", headers=self.auth_b).status_code, 200) self.assertEqual(self.client.get("/api/v1/novels/novel-b", headers=self.auth_b).status_code, 200) self.assertEqual(self.client.get("/api/v1/files/file-b/content", headers=self.auth_b).status_code, 200) def test_follow_bulk_upsert_uses_current_user_and_deduplicates(self) -> None: payload = { "items": [ { "platform": "pixiv", "creator_id": "origin-1", "creator_name": "Origin One", "creator_handle": "origin_one", "profile_url": "https://www.pixiv.net/users/origin-1", "metadata": {"user_id": "user-b"}, }, { "platform": "pixiv", "creator_id": "origin-1", "creator_name": "Origin One Duplicate", }, { "platform": "x", "creator_id": "sakura", "creator_handle": "sakura", "profile_url": "https://x.com/sakura", }, ] } response = self.client.post("/api/v1/follows/bulk-upsert", headers=self.auth_a, json=payload) self.assertEqual(response.status_code, 200) data = response.json()["data"] self.assertEqual(data["created"], 2) self.assertEqual(data["updated"], 0) self.assertEqual(data["skipped"], 1) follows_a = self.client.get("/api/v1/follows", headers=self.auth_a).json()["data"] follows_b = self.client.get("/api/v1/follows", headers=self.auth_b).json()["data"] self.assertEqual({item["creator_id"] for item in follows_a}, {"origin-1", "sakura"}) self.assertEqual({item["creator_id"] for item in follows_b}, {"creator-b"}) def test_novel_series_summary_defers_chapter_loading(self) -> None: summary = self.client.get("/api/v1/novels/series?include_chapters=false", headers=self.auth_a) self.assertEqual(summary.status_code, 200) item = summary.json()["data"][0] self.assertEqual(item["series_id"], "series-a") self.assertEqual(item["chapter_count"], 1) self.assertEqual(item["chapters"], []) detail = self.client.get("/api/v1/novels/series/series-a", headers=self.auth_a) self.assertEqual(detail.status_code, 200) self.assertEqual(len(detail.json()["data"]["chapters"]), 1) self.assertEqual(self.client.get("/api/v1/novels/series/series-a", headers=self.auth_b).status_code, 404) def test_batch_delete_novels_by_series_id(self) -> None: response = self.client.post( "/api/v1/novels/batch-delete", headers=self.auth_a, json={"ids": [], "series_ids": ["series-a"]}, ) self.assertEqual(response.status_code, 200) self.assertEqual(response.json()["data"]["deleted"], 1) self.assertEqual(self.client.get("/api/v1/novels/series/series-a", headers=self.auth_a).status_code, 404) def test_upload_init_rejects_large_path_traversal_and_disallowed_mime(self) -> None: base_payload = { "sha256": "a" * 64, "file_name": "safe.png", "file_size": 10, "mime_type": "image/png", "resource_type": "image", } too_large = {**base_payload, "file_size": 2 * 1024 * 1024} traversal = {**base_payload, "file_name": "../secret.png"} windows_traversal = {**base_payload, "file_name": r"..\\secret.png"} bad_mime = {**base_payload, "mime_type": "application/x-msdownload"} self.assertEqual(self.client.post("/api/v1/upload/init", headers=self.auth_a, json=too_large).status_code, 413) self.assertEqual(self.client.post("/api/v1/upload/init", headers=self.auth_a, json=traversal).status_code, 400) self.assertEqual(self.client.post("/api/v1/upload/init", headers=self.auth_a, json=windows_traversal).status_code, 400) self.assertEqual(self.client.post("/api/v1/upload/init", headers=self.auth_a, json=bad_mime).status_code, 415) ok = self.client.post("/api/v1/upload/init", headers=self.auth_a, json=base_payload) self.assertEqual(ok.status_code, 200) self.assertFalse(ok.json()["data"]["exists"]) def test_external_url_collection_allows_only_whitelisted_public_domains(self) -> None: self.assertTrue(is_allowed_external_url("https://www.pixiv.net/artworks/123")) self.assertTrue(is_allowed_external_url("https://i.pximg.net/img-original/example.jpg")) blocked = [ "http://127.0.0.1:8000/internal", "http://localhost/admin", "http://10.0.0.5/private", "http://172.16.0.1/private", "http://192.168.1.1/private", "http://169.254.169.254/latest/meta-data", "file:///etc/passwd", "https://evil.example.test/image.jpg", ] for url in blocked: with self.subTest(url=url): self.assertFalse(is_allowed_external_url(url)) def test_admin_dependency_requires_admin_role(self) -> None: self.assertEqual(self.client.get("/api/v1/admin/probe").status_code, 401) self.assertEqual(self.client.get("/api/v1/admin/probe", headers=self.auth_a).status_code, 403) self.assertEqual(self.client.get("/api/v1/admin/probe", headers=self.auth_admin).status_code, 200)