Skip to content

armgit / peach

Public Imported from GitHub
0

Peach: Local-first video metadata scraper and media manager.

30.8 KB
Raw Blame
"""云下载的 Web 一侧:任务列表与提交取消的路由、设置块的形状与凭据去向。

应用用临时账本与临时凭据目录建,远端换成假 provider,不起 `lifespan`。
"""
from __future__ import annotations

import json
import tempfile
import unittest
from pathlib import Path
from unittest import mock

import httpx
from fastapi.testclient import TestClient

from peach import download_postprocess, entities
from peach import downloads as dl
from peach import downloads_clouddrive, web_downloads
from peach.api import create_app
from peach.config import PeachSettings
from peach.push_discovery import CloudPrefix, PushDiscoveryConfig
from support.ledger import fresh_ledger

HASH = "c9e15763f722f23e98a29decdfae341b98d53056"


class FakeProvider:
    key = "115"

    def __init__(self):
        self.submitted = []
        self.cancelled = []

    def submit(self, magnet, target):
        self.submitted.append((magnet.info_hash, target))
        return dl.RemoteStatus(dl.RUNNING, "r1", magnet.name)

    def status(self, task):
        return dl.RemoteStatus(dl.RUNNING, "r1")

    def landed(self, task):
        return False

    def cancel(self, task):
        self.cancelled.append(task.id)


class FakeBrowserLogin:
    """`downloads_pikpak_browser.BrowserLogin` 的替身:不拉起浏览器,只记被调了几次。"""

    def __init__(self, available=True):
        self.is_available = available
        self.state = {"state": "idle", "message": ""}
        self.started = self.cancelled = 0

    def available(self):
        return self.is_available

    def status(self):
        return dict(self.state)

    def start(self):
        if not self.is_available:
            raise ValueError("这台电脑上没有找到 Chrome 或 Edge,用不了浏览器登录")
        self.started += 1
        self.state = {"state": "waiting", "message": "浏览器窗口已打开,在里面登录 PikPak"}
        return self.status()

    def cancel(self):
        self.cancelled += 1
        self.state = {"state": "cancelled", "message": "已取消浏览器登录"}
        return self.status()


class _App(unittest.TestCase):
    def setUp(self):
        self.tmp = tempfile.TemporaryDirectory()
        self.addCleanup(self.tmp.cleanup)
        self.root = Path(self.tmp.name).resolve()
        self.app = create_app(PeachSettings(
            db_path=fresh_ledger(self.root), configured=True, token="",
            follow_state_root=self.root / "state", secrets_root=self.root / "secrets"))
        self.addCleanup(self.app.state.http_transport.close)
        self.service = self.app.state.downloads
        self.provider = FakeProvider()
        self.service.providers = lambda key: self.provider
        self.service.channel_catalog = lambda: {"providers": [
            {"key": key, "label": label, "configured": True, "target": self.service.config.targets.get(key, "")}
            for key, label in dl.PROVIDER_LABELS.items()], "problems": []}
        self.client = TestClient(self.app)

    def secrets(self) -> dict:
        folder = self.root / "secrets" / "follow"
        return {path.name: path.read_text(encoding="utf-8") for path in folder.glob("*.json")}


class RouteTests(_App):
    def test_download_artwork_uses_local_library_images_after_ingestion(self):
        from PIL import Image

        contract = self.app.state.web_contract
        contract.cover_root = self.root / "covers"
        contract.avatar_root = self.root / "avatars"
        contract.cover_root.mkdir()
        contract.avatar_root.mkdir()
        Image.new("RGB", (640, 360), "white").save(contract.cover_root / "ABC-123.jpg")
        with self.service.store.database.write_transaction() as connection:
            asset_id = connection.execute(
                "INSERT INTO asset(location,path,name,medium,code) VALUES(?,?,?,?,?)",
                ("115", "B:\\云下载\\ABC-123.mp4", "ABC-123.mp4", "video", "ABC-123"),
            ).lastrowid
            performer_id = entities.upsert_asset_entity(
                connection, kind="performer", name="测试女优", asset_id=asset_id,
                role="performer", source="test:downloads")
        Image.new("RGB", (128, 128), "white").save(
            contract.avatar_root / f"performer-{performer_id}.img", format="JPEG")
        task = self.service.store.save(dl.DownloadTask(
            id=0, info_hash="d" * 40, provider="115", source_uri="magnet:?xt=urn:btih:" + HASH,
            display_name="ABC-123", code="ABC-123", target="/云下载", state=dl.REMOTE_RUNNING,
            asset_id=asset_id))
        self.assertIsNone(self.client.get("/api/downloads").json()["tasks"][0]["artwork"])
        task.state = dl.INGESTED
        self.service.store.save(task)
        artwork = self.client.get("/api/downloads").json()["tasks"][0]["artwork"]
        self.assertTrue(artwork["has_cover"])
        self.assertEqual(artwork["cover_key"], "ABC-123")
        self.assertEqual([(ref["name"], ref["has_image"]) for ref in artwork["performer_entities"]],
                         [("测试女优", True)])
        self.assertEqual(self.provider.submitted, [])

    def test_the_contract_and_the_app_share_one_service(self):
        self.assertIs(self.app.state.web_contract.downloads, self.service)

    def test_a_pasted_magnet_is_submitted_listed_and_cancelled(self):
        response = self.client.post("/api/downloads", json={
            "magnet": f"magnet:?xt=urn:btih:{HASH}&dn=ABC-123", "provider": "115",
            "target": "/115/云下载", "code": "ABC-123"})
        self.assertEqual(response.status_code, 200, response.text)
        body = response.json()
        self.assertEqual((body["outcome"], body["task"]["origin"]), ("submitted", "paste"))
        listed = self.client.get("/api/downloads").json()
        self.assertEqual([task["info_hash"] for task in listed["tasks"]], [HASH])
        self.assertEqual([row["key"] for row in listed["providers"]], ["115", "pikpak"])
        cancelled = self.client.post("/api/downloads/cancel", json={"id": body["task"]["id"]})
        self.assertEqual(cancelled.json()["task"]["state"], dl.CANCELLED)
        self.assertEqual(self.provider.cancelled, [body["task"]["id"]])

    def test_bad_input_is_a_400_with_the_reason(self):
        response = self.client.post("/api/downloads", json={"magnet": "nope", "provider": "115",
                                                            "target": "/115/a"})
        self.assertEqual(response.status_code, 400)
        self.assertIn("infohash", response.text)
        self.assertEqual(self.client.post("/api/downloads/cancel", json={}).status_code, 400)

    def test_download_pages_return_a_cursor_and_reject_invalid_positions(self):
        for number in range(3):
            self.service.store.save(dl.DownloadTask(
                id=0, info_hash=f"{number:040x}", provider="115", source_uri="magnet:?xt=urn:btih:" + HASH,
                display_name="ABC-123.mp4", target="/115/云下载", state=dl.SUBMITTED))
        first = self.client.get("/api/downloads?limit=2").json()
        self.assertTrue(first["has_more"])
        self.assertEqual(first["tasks"][0]["display_code"], "ABC-123")
        last = self.client.get(f"/api/downloads?limit=2&before_id={first['next_before_id']}").json()
        self.assertEqual(len(last["tasks"]), 1)
        self.assertFalse(last["has_more"])
        numbered = self.client.get('/api/downloads?limit=2&page=2').json()
        self.assertEqual([row['id'] for row in numbered['tasks']], [row['id'] for row in last['tasks']])
        self.assertEqual(numbered['total'], 3)
        self.assertEqual(numbered['page'], 2)
        beyond = self.client.get('/api/downloads?limit=2&page=99').json()
        self.assertEqual(beyond['page'], 2)
        for page in ('0', '-1', 'invalid'):
            self.assertEqual(self.client.get(f'/api/downloads?page={page}').status_code, 400)
        for position in ("nope", "0", "-1"):
            self.assertEqual(self.client.get(f"/api/downloads?before_id={position}").status_code, 400)

    def test_download_titles_use_bound_work_metadata_without_changing_saved_tasks(self):
        with self.service.store.database.write_transaction() as connection:
            asset_id = connection.execute(
                "INSERT INTO asset(location,path,name,medium,code,catalog_title) VALUES(?,?,?,?,?,?)",
                ("115", "B:\\云下载\\ABC-123.mp4", "ABC-123.mp4", "video", "ABC-123", "制作记录与访谈"),
            ).lastrowid
        bound = self.service.store.save(dl.DownloadTask(
            id=0, info_hash="a" * 40, provider="115", source_uri="magnet:?xt=urn:btih:" + HASH,
            display_name="ABC-123", target="/云下载", state=dl.INGESTED,
            title="ABC-123", asset_id=asset_id))
        named = self.service.store.save(dl.DownloadTask(
            id=0, info_hash="b" * 40, provider="115", source_uri="magnet:?xt=urn:btih:" + HASH,
            display_name="XYZ-456 制作花絮.mp4", target="/云下载", state=dl.FAILED, code="XYZ-456"))
        listed = {task["id"]: task for task in self.client.get("/api/downloads").json()["tasks"]}
        self.assertEqual((listed[bound.id]["display_code"], listed[bound.id]["display_title"]),
                         ("ABC-123", "制作记录与访谈"))
        self.assertEqual((listed[named.id]["display_code"], listed[named.id]["display_title"]),
                         ("XYZ-456", "制作花絮"))
        self.assertEqual(self.service.store.get(bound.id).title, "ABC-123")
        self.assertIsNone(self.service.store.get(bound.id).code)
        with self.service.store.database.write_transaction() as connection:
            connection.execute("UPDATE asset SET catalog_title=NULL,original_title=? WHERE id=?",
                               ("原始作品标题", asset_id))
        self.assertEqual(self.client.get("/api/downloads").json()["tasks"][1]["display_title"], "原始作品标题")
        bound.code = "DEF-456"
        bound.title = "提交时的标题"
        self.service.store.save(bound)
        conflicted = self.client.get("/api/downloads").json()["tasks"][1]
        self.assertEqual((conflicted["display_code"], conflicted["display_title"]), ("DEF-456", "提交时的标题"))

    def test_failed_postprocess_can_be_requeued_without_resubmitting(self):
        result = self.service.submit(
            source=f"magnet:?xt=urn:btih:{HASH}&dn=ABC-123", provider="115",
            target="/115/云下载", code="ABC-123")
        result.task.state = dl.INGESTED
        result.task.postprocess_state = dl.POSTPROCESS_FAILED
        self.service.store.save(result.task)
        queued = []
        self.service.after_ingest = lambda task: queued.append(task.id)
        response = self.client.post("/api/downloads/postprocess", json={"id": result.task.id})
        self.assertEqual(response.status_code, 200, response.text)
        self.assertEqual(response.json()["task"]["postprocess_state"], dl.POSTPROCESS_PENDING)
        self.assertEqual(queued, [result.task.id])

    def test_postprocess_enqueue_is_persisted_and_adopts_an_existing_queue_row(self):
        result = self.service.submit(
            source=f"magnet:?xt=urn:btih:{HASH}&dn=ABC-123", provider="115",
            target="/115/云下载", code="ABC-123")
        result.task.state = dl.INGESTED
        result.task.next_check_at = None
        result.task.postprocess_state = dl.POSTPROCESS_PENDING
        self.service.store.save(result.task)
        contract = self.app.state.web_contract
        wake = mock.patch.object(contract.followups, "wake")
        wake.start()
        self.addCleanup(wake.stop)
        first = download_postprocess.enqueue(contract, result.task)
        self.assertIsNotNone(first)
        self.assertEqual(self.service.store.get(result.task.id).postprocess_state,
                         dl.POSTPROCESS_QUEUED)
        self.service.store.postprocess(result.task.id, dl.POSTPROCESS_PENDING)
        second = download_postprocess.enqueue(contract, self.service.store.get(result.task.id))
        self.assertEqual(second, first)
        self.assertEqual(self.service.store.get(result.task.id).postprocess_run_id, first)


class SettingsBlockTests(_App):
    """CloudDrive2 那一侧换成 `self.answer`;没有令牌时走真的 `check`,它在连网之前就停。"""

    def test_invalid_service_address_is_refused_before_settings_or_token_are_saved(self):
        self.service.save_settings({"clouddrive_address": "localhost:19798", "wait_hours": 48}, self.roots())
        before = self.service.settings.path.read_bytes()
        stored_secrets = self.secrets()
        client = TestClient(self.app, client=("127.0.0.1", 50000), base_url="http://127.0.0.1")
        response = client.post("/api/configuration/downloads", json={
            "clouddrive_address": "http://localhost:bad-port", "token": "test-only-new-token"})
        self.assertEqual(response.status_code, 400, response.text)
        self.assertIn("端口", response.text)
        self.assertEqual(self.service.settings.path.read_bytes(), before)
        self.assertEqual(self.secrets(), stored_secrets)

    def test_saved_invalid_address_and_token_keep_configuration_readable_and_repairable(self):
        from peach import routes_configuration, settings_file
        from peach.downloads_channels import LibraryChannels

        self.service.settings.path.parent.mkdir(parents=True, exist_ok=True)
        raw = {"clouddrive_address": "http://localhost:bad-port", "targets": {"115": "/115/Movies"},
               "pikpak_root": "", "wait_hours": 48}
        self.service.settings.path.write_text(json.dumps(raw), encoding="utf-8")
        before = self.service.settings.path.read_bytes()
        self.service.config = self.service.settings.load()
        self.service.credentials.save(dl.CLOUDDRIVE_CREDENTIAL, {"token": "test-only-token"})
        self.service.landing.declared_roots = {"115": ("R:\\Media",)}
        self.service.channel_catalog = LibraryChannels(self.service, lambda: {})
        config = settings_file.PeachConfig(self.root, self.root / "config.toml", present=True)
        client = TestClient(self.app, client=("127.0.0.1", 50000), base_url="http://127.0.0.1")
        with mock.patch.object(settings_file, "load_config", return_value=config), \
                mock.patch.object(routes_configuration, "snapshot", return_value={"port": 8900, "media_dirs": []}):
            response = client.get("/api/configuration")
        self.assertEqual(response.status_code, 200, response.text)
        state = response.json()["downloads"]
        self.assertEqual(state["config"], raw)
        self.assertTrue(state["token_set"])
        self.assertTrue(any("端口" in problem for problem in state["problems"]))
        self.assertEqual(state["providers"], [])
        self.assertNotIn("test-only-token", response.text)
        self.assertEqual(self.service.settings.path.read_bytes(), before)

    def setUp(self):
        super().setUp()
        real = downloads_clouddrive.check
        self.checked = []
        self.answer = lambda address, target: downloads_clouddrive.empty_report(address)

        def check(address, token, target, *, hints=downloads_clouddrive.Hints()):
            if not token:
                return real(address, token, target, hints=hints)
            self.checked.append({"address": address, "token": token, "target": target, "hints": hints})
            return self.answer(address, target)

        patcher = mock.patch.object(downloads_clouddrive, "check", check)
        patcher.start()
        self.addCleanup(patcher.stop)

    def roots(self):
        return {"pikpak": ("P:\\",)}

    def suggest(self, path: str, exists: bool):
        def answer(address, target):
            report = downloads_clouddrive.empty_report(address)
            report["suggested_target"] = {"path": path, "exists": exists}
            if exists:
                report["folder"] = {"path": path, "can_offline": True, "cloud": "115open"}
            return report
        self.answer = answer

    def test_saving_with_a_blank_target_fills_in_the_suggested_folder_when_it_exists(self):
        self.suggest("/115open/云下载", True)
        payload = web_downloads.save_settings(self.service, {
            "clouddrive_address": "127.0.0.1:19798", "token": "cd2-secret", "targets": {"115": ""},
            "wait_hours": 24}, self.roots())
        self.assertEqual(self.checked[0]["target"], "")
        self.assertEqual(self.checked[0]["token"], "cd2-secret")
        self.assertEqual(payload["config"]["targets"], {"115": "/115open/云下载"})
        self.assertEqual(payload["config"]["wait_hours"], 24)
        self.assertEqual(payload["report"]["folder"]["path"], "/115open/云下载")
        self.assertNotIn("cd2-secret", json.dumps(payload, ensure_ascii=False))
        saved = json.loads((self.root / "state" / dl.SETTINGS_FILENAME).read_text(encoding="utf-8"))
        self.assertEqual(saved["targets"], {"115": "/115open/云下载"})
        self.assertEqual(self.service.config.targets, {"115": "/115open/云下载"})

    def test_saving_with_a_blank_target_keeps_it_blank_when_the_suggested_folder_is_missing(self):
        self.suggest("/115open/云下载", False)
        payload = web_downloads.save_settings(self.service, {
            "clouddrive_address": "127.0.0.1:19798", "token": "cd2-secret", "wait_hours": 24},
            self.roots())
        self.assertEqual(payload["config"]["targets"], {})
        self.assertEqual(payload["config"]["wait_hours"], 24)
        self.assertEqual(payload["report"]["suggested_target"], {"path": "/115open/云下载", "exists": False})

    def test_saving_checks_the_folder_the_user_filled_in_and_keeps_it(self):
        self.service.landing.declared_roots = self.roots()
        self.suggest("/115open/云下载", True)
        payload = web_downloads.save_settings(self.service, {
            "clouddrive_address": "127.0.0.1:19798", "token": "cd2-secret",
            "targets": {"115": "/115open/自己的"}, "pikpak_account": True}, self.roots())
        self.assertEqual(self.checked[0]["target"], "/115open/自己的")
        self.assertTrue(self.checked[0]["hints"].pikpak_account)
        self.assertEqual(payload["config"]["targets"], {"115": "/115open/自己的"})

    def test_saving_uses_the_stored_token_and_skips_the_check_without_one(self):
        payload = web_downloads.save_settings(self.service, {"clouddrive_address": "127.0.0.1:19798"},
                                              self.roots())
        self.assertIsNone(payload["report"])
        self.assertEqual(self.checked, [])
        self.service.credentials.save(dl.CLOUDDRIVE_CREDENTIAL, {"token": "stored"})
        payload = web_downloads.save_settings(self.service, {"clouddrive_address": "127.0.0.1:19798"},
                                              self.roots())
        self.assertEqual(self.checked[0]["token"], "stored")
        self.assertIsNotNone(payload["report"])
        cleared = web_downloads.save_settings(self.service, {"clear_token": True}, self.roots())
        self.assertIsNone(cleared["report"])

    def test_opening_the_page_checks_the_saved_configuration(self):
        web_downloads.save_settings(self.service, {
            "clouddrive_address": "127.0.0.1:19798", "token": "cd2-secret",
            "targets": {"115": "/115open/已保存"}}, self.roots())
        self.checked.clear()
        client = TestClient(self.app, client=("127.0.0.1", 50000), base_url="http://127.0.0.1")
        response = client.get("/api/configuration/downloads/check")
        self.assertEqual(response.status_code, 200, response.text)
        self.assertEqual(set(response.json()), set(downloads_clouddrive.empty_report("")))
        self.assertEqual((self.checked[0]["address"], self.checked[0]["token"], self.checked[0]["target"]),
                         ("http://127.0.0.1:19798", "cd2-secret", "/115open/已保存"))
        self.assertFalse(self.checked[0]["hints"].pikpak_account)

    def test_the_token_goes_to_the_local_credential_file_only(self):
        payload = web_downloads.save_settings(self.service, {
            "clouddrive_address": "127.0.0.1:19798", "token": "cd2-secret",
            "targets": {"115": "/115/云下载", "pikpak": "/云下载"}, "pikpak_root": "p:\\"},
            self.roots())
        self.assertTrue(payload["token_set"])
        self.assertNotIn("cd2-secret", json.dumps(payload, ensure_ascii=False))
        self.assertEqual(payload["config"]["pikpak_root"], "P:\\")
        self.assertEqual(payload["pikpak_roots"], ["P:\\"])
        self.assertEqual(json.loads(self.secrets()["download-clouddrive2.json"]), {"token": "cd2-secret"})
        state = (self.root / "state" / dl.SETTINGS_FILENAME).read_text(encoding="utf-8")
        self.assertNotIn("cd2-secret", state)

    def test_a_blank_token_keeps_the_saved_one_and_clear_removes_it(self):
        web_downloads.save_settings(self.service, {"token": "cd2-secret"}, self.roots())
        self.assertTrue(web_downloads.save_settings(self.service, {"token": ""}, self.roots())["token_set"])
        cleared = web_downloads.save_settings(self.service, {"clear_token": True}, self.roots())
        self.assertFalse(cleared["token_set"])

    def test_checking_without_a_token_reports_the_problem_without_calling_out(self):
        report = web_downloads.check_clouddrive(self.service, {"clouddrive_address": "127.0.0.1:1"})
        self.assertFalse(report["ok"])
        self.assertIn("API 令牌", report["problems"][0])
        self.assertEqual((report["suggested_target"], report["suggested_pikpak_root"]), (None, ""))

    def test_the_check_takes_the_push_prefixes_and_the_blanks_on_the_form(self):
        self.service.landing.declared_roots = self.roots()
        web_downloads.save_settings(self.service, {"targets": {"115": "/115open/已保存"}}, self.roots())
        prefixes = (CloudPrefix("/115open", "B:\\"),)
        self.service.landing.push_discovery.config = PushDiscoveryConfig(prefixes=prefixes)
        seen = {}

        def check(address, token, target, *, hints):
            seen.update(target=target, hints=hints)
            return downloads_clouddrive.empty_report(address)

        with mock.patch.object(downloads_clouddrive, "check", check):
            web_downloads.check_clouddrive(self.service, {
                "clouddrive_address": "127.0.0.1:19798", "token": "t", "target": "", "pikpak_root": ""})
            self.assertEqual((seen["target"], seen["hints"].prefixes, seen["hints"].pikpak_root),
                             ("", prefixes, ""))
            self.assertFalse(seen["hints"].pikpak_account)
            web_downloads.check_clouddrive(self.service, {"clouddrive_address": "127.0.0.1:19798"})
            self.assertEqual(seen["target"], "/115open/已保存")
            web_downloads.check_clouddrive(self.service, {"clouddrive_address": "127.0.0.1:19798",
                                                          "pikpak_account": True})
            self.assertTrue(seen["hints"].pikpak_account)
            self.service.credentials.save(dl.PIKPAK_CREDENTIAL, {"refresh_token": "rt", "username": "u"})
            web_downloads.check_clouddrive(self.service, {"clouddrive_address": "127.0.0.1:19798"})
            self.assertTrue(seen["hints"].pikpak_account)

    def test_creating_a_folder_needs_a_token_and_a_real_folder(self):
        with self.assertRaises(ValueError) as caught:
            web_downloads.create_clouddrive_folder(self.service, {
                "clouddrive_address": "127.0.0.1:1", "path": "/115open/云下载"})
        self.assertIn("API 令牌", str(caught.exception))
        with self.assertRaises(ValueError) as caught:
            web_downloads.create_clouddrive_folder(self.service, {
                "clouddrive_address": "127.0.0.1:1", "token": "t", "path": "/"})
        self.assertIn("根目录", str(caught.exception))

    def test_a_pikpak_captcha_comes_back_as_a_page_to_open(self):
        def handler(request: httpx.Request) -> httpx.Response:
            return httpx.Response(200, json={"url": "https://user.mypikpak.com/captcha"})
        result = web_downloads.pikpak_login(
            self.service, {"username": "[email protected]", "password": "pw"}, self.roots(),
            transport=httpx.MockTransport(handler))
        self.assertEqual((result["ok"], result["captcha_url"]),
                         (False, "https://user.mypikpak.com/captcha"))
        self.assertFalse(result["settings"]["pikpak"]["logged_in"])
        self.assertNotIn("pw", self.secrets().get("download-pikpak.json", ""))

    def test_the_service_carries_its_own_browser_login_profile(self):
        from peach.downloads_pikpak_browser import BrowserLogin
        login = self.service.pikpak_browser
        self.assertIsInstance(login, BrowserLogin)
        self.assertEqual(login.profile, self.root / "secrets" / "browser-pikpak")

    def test_logging_out_removes_the_pikpak_credentials(self):
        self.service.credentials.save(dl.PIKPAK_CREDENTIAL, {"refresh_token": "rt", "username": "u"})
        self.assertTrue(web_downloads.settings_payload(self.service, {})["pikpak"]["logged_in"])
        self.assertFalse(web_downloads.pikpak_logout(self.service, {})["pikpak"]["logged_in"])
        self.assertNotIn("download-pikpak.json", self.secrets())


class BrowserLoginRouteTests(_App):
    """浏览器登录三条接口只回设置块:状态与有没有浏览器,不回 token。登录在后台等,页面轮询读接口。"""

    URL = "/api/configuration/downloads/pikpak/browser-login"

    def setUp(self):
        super().setUp()
        self.login = FakeBrowserLogin()
        self.service.pikpak_browser = self.login
        self.local = TestClient(self.app, base_url="http://127.0.0.1", client=("127.0.0.1", 123))

    def test_starting_polling_and_cancelling_go_through_the_settings_block(self):
        idle = self.local.get(self.URL)
        self.assertEqual(idle.status_code, 200, idle.text)
        self.assertEqual(idle.json()["pikpak_browser"], {"available": True, "state": "idle", "message": ""})
        started = self.local.post(self.URL).json()
        self.assertEqual((started["pikpak_browser"]["state"], self.login.started), ("waiting", 1))
        self.service.credentials.save(dl.PIKPAK_CREDENTIAL, {
            "refresh_token": "page-refresh", "access_token": "page-access", "client_id": "YUMx5nI8ZU8Ap8pm"})
        self.login.state = {"state": "done", "message": "已用浏览器登录 PikPak"}
        done = self.local.get(self.URL)
        self.assertEqual(done.json()["pikpak"], {"logged_in": True, "username": "", "remember": False,
                                                  "method": "browser"})
        self.assertNotIn("page-refresh", done.text)
        self.assertNotIn("page-access", done.text)
        cancelled = self.local.post(f"{self.URL}/cancel").json()
        self.assertEqual((cancelled["pikpak_browser"]["state"], self.login.cancelled), ("cancelled", 1))

    def test_a_machine_without_a_browser_gets_the_reason(self):
        self.login.is_available = False
        self.assertFalse(self.local.get(self.URL).json()["pikpak_browser"]["available"])
        response = self.local.post(self.URL)
        self.assertEqual(response.status_code, 400)
        self.assertIn("Chrome 或 Edge", response.text)

    def test_a_read_only_side_does_not_open_a_login_window(self):
        self.service.available = False
        self.assertEqual(self.local.post(self.URL).status_code, 400)
        self.assertEqual(self.login.started, 0)

    def test_another_origin_cannot_open_the_window(self):
        response = self.local.post(self.URL, headers={"origin": "https://other.invalid"})
        self.assertEqual(response.status_code, 403)
        self.assertEqual(self.login.started, 0)


class ResourceIndexerRoutes(_App):
    URL = "/api/configuration/indexers"

    def setUp(self):
        super().setUp()
        self.local = TestClient(self.app, base_url="http://127.0.0.1", client=("127.0.0.1", 123))

    def test_credentials_are_local_and_origin_guarded(self):
        body = {"indexers": [{"key": "one", "name": "测试源", "url": "http://indexer.test/api",
                              "api_key": "private-test-key", "enabled": True}]}
        self.assertEqual(self.client.post(self.URL, json=body).status_code, 403)
        self.assertEqual(self.local.post(self.URL, json=body,
                                        headers={"origin": "https://other.invalid"}).status_code, 403)
        response = self.local.post(self.URL, json=body)
        self.assertEqual(response.status_code, 200, response.text)
        self.assertNotIn("private-test-key", response.text)
        self.assertTrue(self.local.get(self.URL).json()["indexers"][0]["api_key_set"])
        self.assertEqual(self.client.get(self.URL).status_code, 403)

    def test_search_endpoint_passes_saved_config_and_returns_candidates(self):
        from peach.resource_search import Indexers
        Indexers(self.service.credentials).save({"indexers": [{
            "key": "one", "name": "测试源", "url": "http://indexer.test/api", "enabled": True}]})
        with mock.patch("peach.web_resource_search.direct_search", return_value={
                "items": [], "warnings": [], "trace": [],
                "next_sources": [], "reference_only": []}) as direct, \
             mock.patch("peach.web_resource_search._SEARCH.run", return_value={
                "ok": True, "state": "ready", "items": [], "warnings": [], "error": ""}) as search:
            response = self.client.get("/api/resources/search?code=ABC-123&goal=chinese")
        self.assertEqual(response.status_code, 200, response.text)
        args = search.call_args.args
        self.assertEqual((args[0][0]["key"], args[1], args[2].goal), ("one", "ABC-123", "chinese"))
        self.assertEqual(direct.call_args.kwargs["goal"], "chinese")
        self.assertEqual(self.client.get("/api/resources/search?code=ABC-123&min_size=-1").status_code, 400)

    def test_switching_magnets_searches_every_source_and_drops_skipped_hashes(self):
        from peach.web_resource_search import q_resource_search
        failed, other = "a" * 40, "b" * 40
        hd = {"source": "manko.fun", "resolution": 1080, "info_hash": failed, "name": "ABC-123"}
        fallback = {"source": "sukebei", "resolution": 1080, "info_hash": other, "name": "ABC-123 FHD"}
        with mock.patch("peach.web_resource_search.direct_search", return_value={
                "items": [hd, fallback], "warnings": [], "trace": [], "next_sources": [], "reference_only": []}) as direct,              mock.patch("peach.web_resource_search._SEARCH.run", return_value={
                "ok": True, "state": "ready", "items": [], "warnings": [], "error": ""}) as search,              mock.patch("peach.web_resource_search.rank_candidates", side_effect=lambda rows, goal: rows):
            result = q_resource_search(self.app.state.web_contract, {"code": "ABC-123", "skip": [failed]})
            self.assertFalse(direct.call_args.kwargs["stop_on_preferred"])
            self.assertIn(failed, search.call_args.args[3])
            self.assertEqual([row["info_hash"] for row in result["items"]], [other])
            q_resource_search(self.app.state.web_contract, {"code": "ABC-123", "skip": "not-a-list"})
            self.assertTrue(direct.call_args.kwargs["stop_on_preferred"])


if __name__ == "__main__":
    unittest.main()