Skip to content

armgit / peach

Public Imported from GitHub
0

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

47.9 KB
Raw Blame
"""厂牌官网采集:候选是假设,判定才是证据。"""
import importlib.util
import sqlite3
import sys
import tempfile
import unittest
from pathlib import Path

REPO = Path(__file__).resolve().parents[1]


def load_module():
    """判据模块的一份独立副本:各条测试往它身上打的补丁(`probe`、`time`)互不串门。"""
    sys.path.insert(0, str(REPO / "src"))
    spec = importlib.util.spec_from_file_location(
        "peach._studio_sites_under_test", REPO / "src" / "peach" / "studio_sites.py")
    module = importlib.util.module_from_spec(spec)
    spec.loader.exec_module(module)
    return module


def run_script(module, args) -> int:
    """跑命令行那一趟,判据换成打过补丁的那份副本。"""
    spec = importlib.util.spec_from_file_location(
        "harvest_studio_sites", REPO / "scripts" / "harvest_studio_sites.py")
    script = importlib.util.module_from_spec(spec)
    spec.loader.exec_module(script)
    script.sites = module
    return script.run(args)


def page(title: str, filler: str = "本編は18歳以上の方のみご覧いただけます。") -> bytes:
    """够长、含标题的正常页面;长度必须越过空壳下限,否则测的就不是标题判定。"""
    body = f"<html><head><title>{title}</title></head><body>{filler * 400}</body></html>"
    return body.encode("utf-8")


class SlugTests(unittest.TestCase):
    def setUp(self):
        self.module = load_module()

    def test_a_multiword_name_yields_both_joined_and_hyphenated_hosts(self):
        """`Wanz Factory` 的真实域名是 wanz-factory.com,而 `Idea Pocket` 是 ideapocket.com。

        两种写法都常见,只推一种就会漏掉一半;连写在前是因为它更常见。
        """
        self.assertEqual(self.module.slugs("Wanz Factory"), ["wanzfactory", "wanz-factory"])
        self.assertEqual(self.module.slugs("MOODYZ"), ["moodyz"])

    def test_a_name_without_latin_letters_yields_no_candidates(self):
        """`无码厂标` 这类名字推不出域名。

        推不出来要老实返回空,让它落到「没有可推导的候选域名」,
        而不是拼出一个必然打不开的地址再去请求一遍。
        """
        self.assertEqual(self.module.slugs("无码厂标"), [])
        self.assertEqual(self.module.candidate_urls("无码厂标"), [])

    def test_candidate_urls_are_unique_and_prefer_dot_com(self):
        urls = self.module.candidate_urls("MOODYZ")
        self.assertEqual(len(urls), len(set(urls)))
        self.assertEqual(urls[0], "https://moodyz.com/")
        self.assertTrue(any(u.endswith("moodyz.jp/") for u in urls))

    def test_the_www_variant_is_not_a_separate_candidate(self):
        """多出来的那一半候选几乎只在失败路径上产生开销。

        transport 开着 follow_redirects,只用 `www.` 的站会从裸域跳过来;而裸域连不上时
        `www.` 基本也连不上。首轮 57 个厂牌 × 8 个候选跑了三个多小时还没完——httpx 把
        单个标量同时当作 connect 和 read 超时,死域名每个吃掉两份。这条测试守的是那次代价。
        """
        urls = self.module.candidate_urls("Wanz Factory")
        self.assertFalse([url for url in urls if url.startswith("https://www.")])
        self.assertEqual(len(urls), 8)   # 2 个 slug 写法 × 4 种域名形态


class NormaliseTests(unittest.TestCase):
    """比对前留下哪些字符,决定了整整一类厂牌能不能被判。"""

    def setUp(self):
        self.module = load_module()

    def test_a_name_written_only_in_japanese_still_has_something_to_compare(self):
        """账本 130 个有作品的厂牌里有 19 个一个拉丁字母都没有。

        只留 ASCII 的话它们的 token 全是空串,`site_verdict` 第一步就判「没有可比对的
        字符」;这些厂牌的域名又推不出来,`--seeds` 是唯一入口,于是人工查到的地址取回
        什么都没用。实测 `https://www.1pondo.tv/` 返回 200、标题正是
        `一本道 | 美を追求する高画質アダルト動画サイト`,照样被写成「没有官网」。
        """
        for name in ("一本道", "カリビアンコム", "スーパーモデルメディア", "俺の素人"):
            self.assertTrue(self.module.normalise(name), name)

    def test_the_prolonged_sound_mark_is_part_of_the_name_but_the_dot_is_not(self):
        """`ー` 在名字里,`・` 是分隔符——两个都住在片假名区,取舍不能按区块一刀切。"""
        self.assertEqual(self.module.normalise("スーパーモデルメディア"), "スーパーモデルメディア")
        self.assertEqual(self.module.normalise("ソフト・オン・デマンド"), "ソフトオンデマンド")

    def test_the_separators_that_never_line_up_are_still_stripped(self):
        """全角括号、`【】` 和日文注音照旧剥掉,否则 `Idea Pocket` 那一类又对不上了。"""
        self.assertEqual(
            self.module.normalise("【IDEAPOCKET (アイデアポケット)】公式サイト"),
            "ideapocketアイデアポケット公式サイト")

    def test_different_studios_are_not_folded_onto_one_token(self):
        """剥字符不能把两家压成同一个串。"""
        self.assertNotEqual(self.module.normalise("MOODYZ"), self.module.normalise("MADONNA"))
        self.assertNotEqual(self.module.normalise("一本道"), self.module.normalise("東京熱"))


class VerdictTests(unittest.TestCase):
    def setUp(self):
        self.module = load_module()

    def test_a_japanese_only_name_is_judged_by_the_same_two_signals(self):
        """`一本道` 实测:标题自述厂牌名 + 页面是成人站,和拉丁名厂牌走的是同一条路。"""
        title = "一本道 | 美を追求する高画質アダルト動画サイト"
        verdict, note = self.module.site_verdict(
            "一本道", 200, page(title), title, "https://www.1pondo.tv/")
        self.assertEqual(verdict, "ok")
        self.assertIn("成人站", note)

    def test_an_uncensored_site_that_says_video_the_other_way_is_still_adult(self):
        """无码站普遍写「アダルト動画」「無修正」,不写「アダルトビデオ」。

        少了这两个词,`www.1pondo.tv` 这种厂牌名自述得清清楚楚的真官网只能判 weak,
        原因仅仅是站上用的是「動画」而不是「ビデオ」。
        """
        for filler in ("高画質アダルト動画サイト", "無修正オリジナル作品"):
            self.assertTrue(self.module.ADULT.search(filler), filler)

    def test_the_adult_check_still_turns_away_the_same_name_companies(self):
        """放宽成人词不能把同名站一起放进来——那正是这条判据存在的理由。"""
        for filler in ("Home | Hunter Engineering Company®",
                       "Bazooka Bass Tubes 车载音响产品目录",
                       "Madonna – Icon Community"):
            self.assertIsNone(self.module.ADULT.search(filler), filler)

    def test_a_title_that_names_the_studio_is_accepted(self):
        """实测标题:分隔符、全角括号和日文注音都对不齐,剥到字母数字才可比。"""
        title = "年齢チェック | 人気知名度NO.1!アダルトビデオ最強のAVメーカー【MOODYZ(ムーディーズ)】公式サイト"
        verdict, _ = self.module.site_verdict("MOODYZ", 200, page(title), title)
        self.assertEqual(verdict, "ok")

        title = "年齢チェック | ハイクオリティのAVメーカー【IDEAPOCKET (アイデアポケット)】公式サイト"
        verdict, _ = self.module.site_verdict("Idea Pocket", 200, page(title), title)
        self.assertEqual(verdict, "ok")

    def test_an_unrelated_company_with_the_same_name_is_not_confirmed(self):
        """「标题里有厂牌名」证明不了这是**这个**厂牌的站。

        实测四例全都 200、都不是停放页、标题里都有厂牌名:`madonna.com` 是歌手麦当娜
        (真站 madonna-av.com)、`hunter.com` 是 Hunter Engineering、`bazooka.com`
        是车载音响。缺的那一半是「这一页是不是 AV 厂牌站」——我们要找的就是 AV 官网,
        成人语境本来就是判据的一部分,不是补丁。这类只能判 weak 交给人看,不能算已确认:
        一条错的官网会被下游当成社媒 handle 的来源。
        """
        for studio, title in [("MADONNA", "Madonna – Icon Community"),
                              ("Hunter", "Home | Hunter Engineering Company®"),
                              ("BAZOOKA", "Bazooka Bass Tubes")]:
            verdict, note = self.module.site_verdict(
                studio, 200, page(title, "公司简介与产品目录。"), title,
                f"https://{studio.lower()}.com/")
            self.assertEqual(verdict, "weak", studio)
            self.assertIn("成人站", note)

    def test_a_derived_domain_on_an_adult_site_counts_even_when_the_title_uses_kana(self):
        """日站普遍把品牌名写成假名,拿拉丁名比标题对整整一类真站都会失败。

        实测:`honnaka.jp` 的标题是「年齢チェック | 全作品、本物中出しのAVメーカー
        【本中】公式サイト」,`muku.tv` 是「【無垢】」,`tameikegoro.jp` 是「【TAMEIKE】」。
        这是系统性漏判,不是个别情况。此时两个独立信号同样成立:域名由厂牌名按固定规则
        推出(不是人喂的),且这一页确实是成人站。
        """
        title = "年齢チェック | 全作品、本物中出しのAVメーカー【本中】公式サイト"
        verdict, note = self.module.site_verdict(
            "Hon Naka", 200, page(title), title, "https://honnaka.jp/",
            derived_hosts=frozenset({"honnaka.jp"}))
        self.assertEqual(verdict, "ok")
        self.assertIn("假名", note)

    def test_a_derived_domain_that_is_not_an_adult_site_is_still_refused(self):
        """`bazooka.com`、`madonna.com` 的域名同样推得出来。

        把它们和上面那条区分开的正是成人语境这一条;少了它,这条规则会把每个
        「同名公司」都当成官网确认掉——比不做这条判定更糟。
        """
        title = "Bazooka Bass Tubes"
        verdict, _ = self.module.site_verdict(
            "BAZOOKA", 200, page(title, "car audio subwoofers. "), title,
            "https://bazooka.com/", derived_hosts=frozenset({"bazooka.com"}))
        self.assertEqual(verdict, "weak")

    def test_a_page_that_says_it_is_unavailable_is_refused(self):
        """2026-09-03 实测的假阳性:`bangbus.com` 与 `monstersofcock.com` 都返回 200、
        82 KB、正文成人词齐全,标题只有 `Site Unavailable`。

        域名确实由厂牌名推出、页面确实是成人站,两个信号都成立,所以旧规则把它们判成 ok,
        写进账本就是两条错的官网。一页自己说自己打不开,就不能当官网证据。
        """
        title = "Site Unavailable"
        verdict, note = self.module.site_verdict(
            "BangBus", 200, page(title, "bang bus porn videos. "), title,
            "https://www.bangbus.com/", derived_hosts=frozenset({"bangbus.com"}))
        self.assertEqual(verdict, "未取得")
        self.assertIn("不可用", note)

    def test_a_maintenance_notice_is_refused_too(self):
        """同一类:日站的维护页也会 200,标题写着メンテナンス。"""
        title = "メンテナンス中 | AVメーカー"
        verdict, _ = self.module.site_verdict(
            "Muku", 200, page(title), title, "https://muku.tv/",
            derived_hosts=frozenset({"muku.tv"}))
        self.assertEqual(verdict, "未取得")

    def test_the_unavailable_check_looks_at_the_title_only(self):
        """反向:这条只判标题,不判正文。

        真站正文里出现 `not found`、`maintenance` 一点也不稀奇——脚本里的报错字符串、
        埋在页面里的客服说明都会命中。停放页那条已经吃过一次「按正文判会误杀」的教训,
        这条不重走。
        """
        title = "年齢チェック | 凌辱、背徳のAVメーカー【ATTACKERS(アタッカーズ)】公式サイト"
        body = page(title, "if(!el){console.error('not found')} 年齢認証 メンテナンス予定はこちら。")
        verdict, _ = self.module.site_verdict(
            "Attackers", 200, body, title, "https://attackers.net/",
            derived_hosts=frozenset())
        self.assertEqual(verdict, "ok")

    def test_a_seeded_url_does_not_get_the_derived_domain_signal(self):
        """人喂进来的地址不能借「域名由厂牌名推出」这条的力。

        那条信号的价值在于域名是独立推出来的;种子是人给的,混在一起就等于自证。
        """
        title = "年齢チェック | マニアック フェチのAVメーカー【ダスッ!】公式サイト"
        seeded, _ = self.module.site_verdict(
            "Das", 200, page(title), title, "https://dasdas.jp/")
        found, _ = self.module.site_verdict(
            "Das", 200, page(title), title, "https://dasdas.jp/",
            derived_hosts=frozenset({"dasdas.jp"}))
        self.assertNotEqual(seeded, "ok", "种子不该借域名推导这条信号确认")
        self.assertEqual(found, "ok", "同一页面若域名是推出来的才算两个独立信号")

    def test_a_derived_domain_that_redirects_elsewhere_loses_the_signal(self):
        """跳走之后,「域名由厂牌名推出」这条证据就不再对我们落到的那一页成立。

        实测:`Natural High` 的一个推导域名重定向到了 `linkedin.com/in/fareedkhan`。
        按请求地址判 derived 的话,一个 LinkedIn 个人主页会被确认成厂牌官网。
        判据必须落在最终主机上。
        """
        title = "Fareed Khan - Ericsson | LinkedIn"
        verdict, _ = self.module.site_verdict(
            "Natural High", 200, page(title, "adult contacts and 18+ groups. "), title,
            "https://www.linkedin.com/in/fareedkhan",
            derived_hosts=frozenset({"naturalhigh.com", "naturalhigh.jp"}))
        self.assertNotEqual(verdict, "ok")

    def test_a_western_studio_page_still_counts_as_adult(self):
        """判据不能只认日文,否则西方厂牌会被一律打成待复核。"""
        title = "BLACKED - The Best Adult Video Site"
        verdict, _ = self.module.site_verdict(
            "Blacked", 200, page(title, "adult video content, 18+ only. "), title,
            "https://blacked.com/")
        self.assertEqual(verdict, "ok")

    def test_a_parked_page_is_rejected_even_though_its_title_echoes_the_name(self):
        """这是猜域名最危险的失败模式。

        抢注页同样回 200,标题里同样有厂牌名(因为那就是域名本身)。只看标题的话
        `moodyz.com` 的停放页会被当成官网采信,再被下游当成社媒 handle 的来源,
        最后把抢注者的账号安到厂牌头上。
        """
        title = "moodyz.com - This domain is for sale"
        verdict, note = self.module.site_verdict("MOODYZ", 200, page(title), title)
        self.assertEqual(verdict, "未取得")
        # 拦在标题还是正文都算数,守的是「被拒绝且理由指向域名出售」。
        self.assertRegex(note, "出售|停放")

    def test_a_generic_domain_whose_title_is_just_its_address_is_rejected(self):
        """停放页规则拦不住这一类:它是个正常的站,只是不属于这个厂牌。

        实测 `https://www.prestige.com/` 返回 200、不是停放页、标题正好是
        `prestige.com`,因此通过了「标题含厂牌名」被判成 Prestige 官网——而真站是
        `prestige-av.com`,`prestige.com` 是另一家公司。判据是:标题若不比域名多说
        任何东西,就等于没有自述身份。
        """
        verdict, note = self.module.site_verdict(
            "Prestige", 200, page("prestige.com"), "prestige.com",
            "https://www.prestige.com/")
        self.assertEqual(verdict, "未取得")
        self.assertIn("域名回显", note)

    def test_a_real_site_is_not_rejected_by_the_domain_echo_rule(self):
        """真站的标题远不止域名,这条规则不能误伤它们。"""
        title = "年齢チェック | 人気知名度NO.1!アダルトビデオ最強のAVメーカー【MOODYZ(ムーディーズ)】公式サイト"
        verdict, _ = self.module.site_verdict(
            "MOODYZ", 200, page(title), title, "https://moodyz.com/")
        self.assertEqual(verdict, "ok")

    def test_a_title_that_is_only_the_brand_name_is_not_a_domain_echo(self):
        """实测误伤:`https://www.naturalhigh.co.jp/` 是 Natural High 的真官网。

        它返回 200、成人站、标题正是 `NATURAL HIGH(ナチュラルハイ)`。把标题
        normalise 成 naturalhigh 再去比主机 naturalhighcojp 的话,它是主机的一部分、
        于是判成「域名回显」——可域名本来就是按厂牌名推出来的,这两者必然互相包含,
        整类真站都会被打掉。所以域名回显要求标题原样印着 TLD。
        """
        title = "NATURAL HIGH(ナチュラルハイ)"
        verdict, _ = self.module.site_verdict(
            "Natural High", 200, page(title, "AVメーカー、18歳未満禁止。"), title,
            "https://www.naturalhigh.co.jp/")
        self.assertEqual(verdict, "ok")

    def test_a_title_that_prints_the_domain_plus_a_real_tagline_is_kept(self):
        """标题里出现域名不等于回显,多说了话就还是自述身份。"""
        title = "attackers.net|凌辱、背徳のAVメーカー【ATTACKERS】公式サイト"
        verdict, _ = self.module.site_verdict(
            "Attackers", 200, page(title), title, "https://attackers.net/")
        self.assertEqual(verdict, "ok")

    def test_a_page_that_only_hands_off_to_a_parking_platform_is_rejected(self):
        """停放页不一定自述在出售,只把访客交给停放平台的路由脚本。"""
        title = "Cruse Group"
        body = page(title) + b'<script>fetch("https://router.parklogic.com/")</script>'
        verdict, note = self.module.site_verdict(
            "Cruse Group", 200, body, title, "https://crusegroup.net/")
        self.assertEqual(verdict, "未取得")
        self.assertIn("parklogic.com", note)

    def test_a_parked_title_is_caught_even_when_the_body_keyword_is_far_down(self):
        """实测漏判:`kawaii.com - domain for sale`。

        关键词确实在正文里,但在第 81683 字节——任何固定的正文扫描窗口都会漏掉它。
        而它就写在标题里,我此前从来没搜过标题。真站的标题不会说自己在出售,
        所以标题可以用最宽的判据。
        """
        title = "kawaii.com - domain for sale"
        body = page("无关内容") + b"x" * 90000 + "domain for sale".encode()
        verdict, note = self.module.site_verdict("kawaii", 200, body, title,
                                                 "https://www.kawaii.com/")
        self.assertEqual(verdict, "未取得")
        self.assertIn("出售", note)

    def test_a_parked_title_with_words_between_is_still_caught(self):
        """实测漏判:`Attackers - The Domain Name Attackers.com is Now For Sale.`

        逐字匹配「domain for sale」对不上——中间插了域名和 is Now。这正是为什么
        标题要单独用更松的判据,而不是把正文那套原样套过来。
        """
        title = "Attackers - The Domain Name Attackers.com is Now For Sale."
        verdict, note = self.module.site_verdict("Attackers", 200, page(title), title,
                                                 "https://attackers.com/")
        self.assertEqual(verdict, "未取得")
        self.assertIn("出售", note)

    def test_a_short_page_is_rejected(self):
        """空壳页也是 200。真站首页实测都在 10 KB 以上。"""
        verdict, note = self.module.site_verdict("MOODYZ", 200, b"<title>MOODYZ</title>", "MOODYZ")
        self.assertEqual(verdict, "未取得")
        self.assertIn("字节", note)

    def test_a_page_that_never_names_the_studio_is_not_guessed_into_ok(self):
        title = "無料動画まとめサイト"
        verdict, _ = self.module.site_verdict("MOODYZ", 200, page(title), title)
        self.assertEqual(verdict, "未取得")

    def test_a_body_only_mention_is_weak_not_ok(self):
        """正文提到不等于这是官网——转载站也会提到厂牌名。

        它值得人看一眼,所以照样出行,但判定必须和标题自述区分开,
        不能混进 ok 里被当成已确认。
        """
        body = page("よくある動画サイト", "MOODYZ の作品を紹介します。")
        verdict, note = self.module.site_verdict("MOODYZ", 200, body, "よくある動画サイト")
        self.assertEqual(verdict, "weak")
        self.assertIn("人工", note)

    def test_a_non_200_is_rejected_before_reading_the_body(self):
        verdict, note = self.module.site_verdict("MOODYZ", 404, page("MOODYZ"), "MOODYZ")
        self.assertEqual(verdict, "未取得")
        self.assertIn("404", note)

    def test_page_title_survives_nested_tags_and_whitespace(self):
        body = b"<html><head><title>\n  <span>MOODYZ</span>  \xe5\x85\xac\xe5\xbc\x8f\n</title></head>"
        self.assertEqual(self.module.page_title(body), "MOODYZ 公式")


    def test_a_shift_jis_page_is_decoded_instead_of_mangled(self):
        """老厂牌站仍有不少是 Shift_JIS。

        硬按 UTF-8 解不会报错,只会把标题变成一串 U+FFFD,然后「标题里没有厂牌名」
        这条判定会把真官网误杀掉——失败是静默的,这正是它值得一个测试的原因。
        """
        title = "MOODYZ 公式サイト"
        body = f"<html><head><title>{title}</title></head></html>".encode("cp932")
        self.assertEqual(self.module.page_title(body), title)


class AliasVerdictTests(unittest.TestCase):
    """账本里的其他写法和规范名一起参与「页面自述厂牌名」那一道。"""

    def setUp(self):
        self.module = load_module()
        # 实测 `https://www.tokyo-hot.com/` 的标题。
        self.title = "年齢確認 | Tokyo-Hot 東京熱 無修正オリジナル徹底凌辱動画"

    def test_the_canonical_name_alone_cannot_match_a_differently_written_site(self):
        """账本挑了简体「东京热」当规范名,站上写的是日文新字体「東京熱」。

        逐字比不上,而这不是页面的问题:页面不会知道账本挑了哪个写法。
        """
        verdict, note = self.module.site_verdict(
            "东京热", 200, page(self.title), self.title, "https://www.tokyo-hot.com/")
        self.assertEqual(verdict, "未取得")
        self.assertIn("没有厂牌名", note)

    def test_a_registered_alias_lets_the_page_declare_itself(self):
        """别名是账本里这个实体自己的名字,不是从页面上猜出来的,所以不放松判据。"""
        verdict, note = self.module.site_verdict(
            "东京热", 200, page(self.title), self.title, "https://www.tokyo-hot.com/",
            aliases=("Tokyo Hot", "Tokyo-Hot", "東京熱"))
        self.assertEqual(verdict, "ok")
        self.assertIn("成人站", note)

    def test_the_note_says_which_spelling_matched(self):
        """复核的人看到标题里写着别的写法,得能立刻明白为什么判成了 ok。"""
        _, note = self.module.site_verdict(
            "东京热", 200, page(self.title), self.title, "https://www.tokyo-hot.com/",
            aliases=("東京熱",))
        self.assertIn("東京熱", note)

    def test_a_canonical_match_does_not_claim_an_alias(self):
        """规范名自己对上的时候判词不加那半句,不然每一行都在解释一件没发生的事。"""
        title = "年齢チェック | AVメーカー【MOODYZ】公式サイト"
        _, note = self.module.site_verdict(
            "MOODYZ", 200, page(title), title, "https://moodyz.com/", aliases=("ムーディーズ",))
        self.assertEqual(note, "标题自述厂牌名,且页面是成人站")

    def test_an_alias_does_not_rescue_a_page_that_is_not_adult(self):
        """别名只替页面找回名字,成人语境那一条照旧要自己站住。"""
        title = "Tokyo Hot Chicken | 東京熱 麻辣炸鸡"
        verdict, _ = self.module.site_verdict(
            "东京热", 200, page(title, "本店の営業時間のご案内。"), title,
            "https://tokyohot-chicken.example/", aliases=("東京熱",))
        self.assertEqual(verdict, "weak")

    def test_a_name_and_aliases_that_are_all_unusable_say_so(self):
        """一个可比对字符都凑不出来时要写清是「没得比」,不是「页面没提」。"""
        title = "なにかのサイト"
        verdict, note = self.module.site_verdict(
            "・", 200, page(title), title, "https://example.com/", aliases=("++",))
        self.assertEqual(verdict, "未取得")
        self.assertIn("没有可比对", note)


class ConfirmedSiteTests(unittest.TestCase):
    """用户确认的官网:补一条页面上没有的信息,不是放宽判据。"""

    def setUp(self):
        self.module = load_module()
        self.title = "SOFT ON DEMAND(ソフト・オン・デマンド)"

    def test_sod_create_points_at_the_parent_company_site(self):
        """裁决本身要能被读出来:地址和理由都写在表里,不散在代码逻辑里。"""
        url, reason = self.module.CONFIRMED_SITES["SOD Create"]
        self.assertEqual(url, "https://www.sod.co.jp/")
        self.assertIn("Soft On Demand", reason)

    def test_a_confirmed_site_is_ok_although_the_title_never_says_the_studio_name(self):
        """这一页 200、是成人站、标题是母公司名——`SOD Create` 这个串它不会有。

        通用判据到此为止只能判「标题与正文都没有厂牌名」,而缺的那条信息
        (这个厂牌属于哪家公司)本来就不在页面上。
        """
        without, note = self.module.site_verdict(
            "SOD Create", 200, page(self.title), self.title, "https://www.sod.co.jp/")
        self.assertEqual(without, "未取得")
        self.assertIn("没有厂牌名", note)
        verdict, note = self.module.site_verdict(
            "SOD Create", 200, page(self.title), self.title, "https://www.sod.co.jp/",
            confirmed=self.module.CONFIRMED_SITES["SOD Create"][1])
        self.assertEqual(verdict, "ok")
        self.assertIn("用户", note)
        self.assertIn("SOFT ON DEMAND", note, "实测标题要留在证据里,才复核得了")

    def test_the_whitelist_does_not_reopen_the_other_gates(self):
        """确认的是「这个地址属于这家公司」,不是「这个地址返回什么都算」。

        域名过期被抢注、站点在维护,页面照样 200——白名单要是把这几道一起绕过去,
        一条停放页就会以 ok 进账本,而它比没有链接更糟。
        """
        reason = self.module.CONFIRMED_SITES["SOD Create"][1]
        for title, hint in [("sod.co.jp is for sale | HugeDomains", "出售"),
                            ("メンテナンス中", "不可用")]:
            verdict, note = self.module.site_verdict(
                "SOD Create", 200, page(title), title, "https://www.sod.co.jp/",
                confirmed=reason)
            self.assertEqual(verdict, "未取得", title)
            self.assertIn(hint, note)
        verdict, _ = self.module.site_verdict(
            "SOD Create", 503, page(self.title), self.title, "https://www.sod.co.jp/",
            confirmed=reason)
        self.assertEqual(verdict, "未取得")

    def test_a_studio_under_its_japanese_name_verifies_on_its_own_title(self):
        """番号站转写的罗马音在厂牌自己站上不出现;账本记日文原名,页面自述就对得上。

        实测 `https://mko-labo.net/top` 返回 200、55 KB、标题
        `トップ | 調教、全身奉仕、醜態...M女専門のAVメーカー【えむっ娘ラボ】公式`。
        罗马音 `M Girls' Lab` 判未取得,那是账本名字的问题,不该靠白名单补。
        """
        url = "https://mko-labo.net/top"
        title = "トップ | 調教、全身奉仕、醜態...M女専門のAVメーカー【えむっ娘ラボ】公式"
        self.assertNotIn("えむっ娘ラボ", self.module.CONFIRMED_SITES)
        romanized, _ = self.module.site_verdict(
            "M Girls' Lab", 200, page(title), title, url)
        self.assertEqual(romanized, "未取得")
        verdict, _ = self.module.site_verdict("えむっ娘ラボ", 200, page(title), title, url)
        self.assertEqual(verdict, "ok")


class PlatformEntityTests(unittest.TestCase):
    """发行平台不是厂牌,「厂牌官网」这条路对它们本来就不成立。"""

    def setUp(self):
        self.module = load_module()

    def test_the_known_platforms_are_recognised_whatever_the_spelling(self):
        for name in ["FC2-PPV", "fc2 ppv", "FC2", "myfans", "MyFans"]:
            self.assertTrue(self.module.is_platform(name), name)

    def test_real_studios_are_not_swept_up(self):
        for name in ["MOODYZ", "Attackers", "SOD Create", "Fitch"]:
            self.assertFalse(self.module.is_platform(name), name)


class PlatformRowTests(unittest.TestCase):
    """平台要出现在复核件上并说明为什么不适用,不能静默少扫一个。

    少扫一个和「扫过但没找到」在复核件上长得一模一样,人只会读到「FC2-PPV 没有官网」。
    """

    def setUp(self):
        self.module = load_module()
        self.tmp = Path(tempfile.mkdtemp())
        self.db = self.tmp / "ledger.db"
        writer = sqlite3.connect(self.db)
        self.addCleanup(writer.close)
        writer.execute(
            "CREATE TABLE entity(id INTEGER PRIMARY KEY, kind TEXT, canonical_name TEXT)")
        writer.execute("CREATE TABLE asset(id INTEGER PRIMARY KEY, medium TEXT)")
        writer.execute("CREATE TABLE asset_entity(asset_id INTEGER, entity_id INTEGER)")
        writer.execute("CREATE TABLE entity_alias(entity_id INTEGER, alias TEXT)")
        writer.execute("INSERT INTO entity VALUES(1,'studio','FC2-PPV')")
        writer.commit()

    def args(self):
        import argparse
        return argparse.Namespace(
            db=self.db, output=self.tmp / "out.csv", seeds=None,
            min_assets=3, only=["FC2-PPV"], interval=0.0, timeout=1.0, limit=0)

    def test_a_platform_gets_its_own_verdict_without_a_single_request(self):
        def refuse(*_args, **_kwargs):
            raise AssertionError("不该为发行平台发出任何请求")
        self.module.probe = refuse
        self.assertEqual(run_script(self.module, self.args()), 0)
        from peach.review_csv import read_rows
        rows = read_rows(self.tmp / "out.csv")
        self.assertEqual(len(rows), 1)
        self.assertEqual(rows[0]["verdict"], self.module.PLATFORM_VERDICT)
        self.assertIn("发行平台", rows[0]["note"])
        self.assertEqual(rows[0]["candidate_url"], "",
                         "一个地址都没试过,就不该在行上留候选")


class LoadStudioTests(unittest.TestCase):
    def setUp(self):
        self.module = load_module()
        self.tmp = Path(tempfile.mkdtemp())
        self.db = self.tmp / "ledger.db"
        writer = sqlite3.connect(self.db)
        self.addCleanup(writer.close)
        writer.execute(
            "CREATE TABLE entity(id INTEGER PRIMARY KEY, kind TEXT, canonical_name TEXT)")
        writer.execute("CREATE TABLE asset(id INTEGER PRIMARY KEY, medium TEXT)")
        writer.execute("CREATE TABLE asset_entity(asset_id INTEGER, entity_id INTEGER)")
        writer.execute("CREATE TABLE entity_alias(entity_id INTEGER, alias TEXT)")
        writer.executemany("INSERT INTO entity_alias VALUES(?,?)",
                           [(1, "Big Pictures"), (1, "ビッグ"), (2, "")])
        writer.executemany("INSERT INTO entity VALUES(?,?,?)",
                           [(1, "studio", "Big"), (2, "studio", "Small"),
                            (3, "performer", "人"), (4, "studio", "Empty")])
        for asset_id, entity_id in [(10, 1), (11, 1), (12, 1), (13, 2), (14, 3)]:
            writer.execute("INSERT OR IGNORE INTO asset VALUES(?,?)", (asset_id, "video"))
            writer.execute("INSERT INTO asset_entity VALUES(?,?)", (asset_id, entity_id))
        writer.commit()

    def reader(self) -> sqlite3.Connection:
        connection = sqlite3.connect(f"file:{self.db}?mode=ro", uri=True)
        self.addCleanup(connection.close)
        return connection

    def test_studios_are_ordered_by_asset_count_and_filtered_by_minimum(self):
        connection = self.reader()
        self.assertEqual([r["studio"] for r in self.module.load_studios(connection, 1)],
                         ["Big", "Small"])
        self.assertEqual([r["studio"] for r in self.module.load_studios(connection, 3)],
                         ["Big"])

    def test_a_named_studio_is_loaded_even_though_it_is_under_the_minimum(self):
        """指名就是「不管几部都要这一个」。

        BangBus、BangBros18 各只有 1 部视频,OPPAI、MonstersOfCock 各 2 部,全部低于默认的 3。
        作品数门槛照旧作用于默认路径,这里只是不再让它挡住指名的目标。
        """
        rows = self.module.load_named_studios(self.reader(), ["Small"])
        self.assertEqual(rows, [{"entity_id": 2, "studio": "Small", "assets": 1}])

    def test_a_named_studio_with_no_video_at_all_still_comes_back(self):
        """一部视频都没有的厂牌也要能补官网——它的作品可能全是图片,或者刚建实体。

        默认路径用 JOIN 数作品,这种厂牌根本不会出现;指名路径必须把它取出来并记 0,
        而不是当成「没这个厂牌」。
        """
        rows = self.module.load_named_studios(self.reader(), ["Empty"])
        self.assertEqual(rows, [{"entity_id": 4, "studio": "Empty", "assets": 0}])

    def test_named_studios_keep_the_order_they_were_given(self):
        """复核件的行序要可预期:给的顺序就是写出来的顺序。"""
        rows = self.module.load_named_studios(self.reader(), ["Small", "Big"])
        self.assertEqual([r["studio"] for r in rows], ["Small", "Big"])

    def test_aliases_come_back_per_entity_and_only_for_the_ids_asked_for(self):
        """别名一次查完:默认扫描有一百多家,每家一次往返换不来任何东西。"""
        self.assertEqual(self.module.load_aliases(self.reader(), [1, 2, 4]),
                         {1: ("Big Pictures", "ビッグ")})

    def test_asking_for_nothing_does_not_hit_the_database(self):
        """`--limit 0` 之后可能一家都不剩,空 IN 列表是个语法错误。"""
        self.assertEqual(self.module.load_aliases(self.reader(), []), {})

    def test_an_empty_alias_row_is_not_a_spelling(self):
        """空串进了表,`site_verdict` 会拿到一个 normalise 后为空的写法:白占一次比对。"""
        self.assertEqual(self.module.load_aliases(self.reader(), [2]), {})

    def test_a_name_the_ledger_does_not_have_fails_loudly(self):
        """拼错的名字必须报错。

        指名用法下静悄悄少扫一个,在复核件上和「扫过但没找到」长得一模一样;
        一个 typo 会被当成「这家没有官网」的结论。同名的 performer 也不算——
        只认 `kind='studio'`。
        """
        with self.assertRaises(SystemExit) as caught:
            self.module.load_named_studios(self.reader(), ["Big", "Attackers", "人"])
        self.assertIn("Attackers", str(caught.exception))
        self.assertIn("人", str(caught.exception))


class ProbeRetryTests(unittest.TestCase):
    """传输层抖动不是结论。

    实测 `www.naturalhigh.co.jp` 第一次 `ReadTimeout`,同一地址再取就是 200、标题
    `NATURAL HIGH(ナチュラルハイ)`。没有重试时那一次抖动直接写成「这家没有官网」,
    而账本里少一条 official 链接,下游的图标采集就整整跳过这个厂牌。
    """

    def setUp(self):
        self.module = load_module()
        self.calls: list[str] = []
        self.slept: list[float] = []
        self.module.crawler_client = lambda: None
        self.module.time = type("clock", (), {
            "sleep": lambda _self, seconds: self.slept.append(seconds),
            "monotonic": lambda _self: 0.0,
        })()

    def transport(self, outcomes):
        """按 `outcomes` 依次作答:异常就抛,元组就当成一次成功的响应。"""
        module = self.module
        results = list(outcomes)

        class Fake:
            def __init__(self, client, *, owns_client=False):
                pass

            def __call__(self, request, timeout, limit):
                answer = results.pop(0)
                if isinstance(answer, Exception):
                    raise answer
                status, body, url = answer
                return type("response", (), {"status": status, "body": body, "url": url})()

            def close(self):
                pass

        module.HttpxTransport = Fake
        return module

    def test_a_transport_blip_is_retried_and_then_succeeds(self):
        module = self.transport([TimeoutError("read timed out"),
                                 (200, b"body", "https://www.naturalhigh.co.jp/")])
        status, body, final = module.probe("http://www.naturalhigh.co.jp/", 8.0, backoff=0.0)
        self.assertEqual((status, body), (200, b"body"))
        self.assertEqual(final, "https://www.naturalhigh.co.jp/")
        self.assertEqual(self.slept, [0.0])

    def test_the_last_failure_is_raised_after_the_retries_run_out(self):
        """一直连不上就得原样抛出来,让上层把真实异常名写进复核件。"""
        module = self.transport([TimeoutError("1"), TimeoutError("2"), TimeoutError("3")])
        with self.assertRaises(TimeoutError):
            module.probe("https://dead.example/", 8.0, backoff=0.0)
        self.assertEqual(self.slept, [0.0, 0.0])

    def test_an_http_status_is_not_retried(self):
        """404 是站点的回答,不是抖动。重试它只会把整批时间翻三倍。"""
        module = self.transport([(404, b"", "https://x.example/")])
        self.assertEqual(module.probe("https://x.example/", 8.0)[0], 404)
        self.assertEqual(self.slept, [])


class RunTrailTests(unittest.TestCase):
    """失败行要看得见是在哪几个地址上失败的。

    后一个候选覆盖前一个的话:`SOD Create` 试了六个地址,复核件上只剩最后那个的
    「取不到:ConnectError」,而真正值得看的是被盖掉的 `www.sod.co.jp`——200、成人站、
    标题 `SOFT ON DEMAND(ソフト・オン・デマンド)`。判未取得可以,看不见理由不行。

    现在这条用 `Prestige` 复现同一个形状:`SOD Create` 已进 `CONFIRMED_SITES`,第一个
    候选就是确认地址且直接采信,走不到「一串候选全失败」这条路了。
    """

    def setUp(self):
        self.module = load_module()
        self.tmp = Path(tempfile.mkdtemp())
        self.db = self.tmp / "ledger.db"
        writer = sqlite3.connect(self.db)
        self.addCleanup(writer.close)
        writer.execute(
            "CREATE TABLE entity(id INTEGER PRIMARY KEY, kind TEXT, canonical_name TEXT)")
        writer.execute("CREATE TABLE asset(id INTEGER PRIMARY KEY, medium TEXT)")
        writer.execute("CREATE TABLE asset_entity(asset_id INTEGER, entity_id INTEGER)")
        writer.execute("CREATE TABLE entity_alias(entity_id INTEGER, alias TEXT)")
        writer.execute("INSERT INTO entity VALUES(1,'studio','Prestige')")
        writer.commit()
        self.module.time = type("clock", (), {
            "sleep": lambda _self, seconds: None,
            "monotonic": lambda _self: 0.0,
        })()

    def args(self, seeds: Path | None = None):
        import argparse
        return argparse.Namespace(
            db=self.db, output=self.tmp / "out.csv", seeds=seeds,
            min_assets=3, only=["Prestige"], interval=0.0, timeout=1.0, limit=0)

    def row(self) -> dict:
        from peach.review_csv import read_rows
        rows = read_rows(self.tmp / "out.csv")
        self.assertEqual(len(rows), 1)
        return rows[0]

    def probe_map(self, answers: dict):
        def probe(url, timeout, **kwargs):
            answer = answers[url]
            if isinstance(answer, Exception):
                raise answer
            return answer
        self.module.probe = probe

    def test_every_candidate_leaves_its_reason_in_the_note(self):
        seeds = self.tmp / "seeds.csv"
        seeds.write_text("studio,site\nPrestige,https://prestige.co.jp/\n"
                         "Prestige,https://www.prestige-av.jp/\n", encoding="utf-8")
        title = "プレステージ"
        self.probe_map({
            "https://prestige.co.jp/": ConnectionError("handshake"),
            "https://www.prestige-av.jp/": (200, page(title),
                                            "https://www.prestige-av.jp/"),
            "https://prestige.com/": (200, page("Prestige.com is for sale"),
                                      "https://www.hugedomains.com/x"),
            "https://prestige.jp/": ConnectionError("nx"),
            "https://prestige-av.com/": ConnectionError("nx"),
            "https://prestige.tv/": ConnectionError("nx"),
        })
        self.assertEqual(run_script(self.module, self.args(seeds)), 0)
        row = self.row()
        self.assertEqual(row["verdict"], "未取得")
        self.assertIn("https://prestige.co.jp/ → 取不到:ConnectionError", row["note"])
        self.assertIn("プレステージ", row["note"])
        # 行上的 url/标题/sha256 仍归最后一个真取回字节的候选,方便按 sha256 复现;
        # 「都试过哪些」由 note 承担。
        self.assertIn("hugedomains", row["final_url"])

    def test_a_confirmed_row_keeps_the_single_reason_not_the_trail(self):
        """采信了就不再堆一串理由:ok 那一行只该说这一个地址为什么成立。"""
        seeds = self.tmp / "seeds.csv"
        seeds.write_text("studio,site\nPrestige,https://dead.example/\n"
                         "Prestige,https://www.prestige-av.jp/\n", encoding="utf-8")
        title = "年齢チェック | AVメーカー【PRESTIGE(プレステージ)】公式サイト"
        self.probe_map({
            "https://dead.example/": ConnectionError("nx"),
            "https://www.prestige-av.jp/": (200, page(title),
                                            "https://www.prestige-av.jp/"),
        })
        self.assertEqual(run_script(self.module, self.args(seeds)), 0)
        row = self.row()
        self.assertEqual(row["verdict"], "ok")
        self.assertEqual(row["final_url"], "https://www.prestige-av.jp/")
        self.assertNotIn("→", row["note"])


class ConfirmedRunTests(unittest.TestCase):
    """确认过的地址要真的走到 `run()` 里,并且排在所有推导候选前面。

    `SOD Create` 推得出九个地址,八个是死的;确认地址排最前就只发一个请求。
    """

    def setUp(self):
        self.module = load_module()
        self.tmp = Path(tempfile.mkdtemp())
        self.db = self.tmp / "ledger.db"
        writer = sqlite3.connect(self.db)
        self.addCleanup(writer.close)
        writer.execute(
            "CREATE TABLE entity(id INTEGER PRIMARY KEY, kind TEXT, canonical_name TEXT)")
        writer.execute("CREATE TABLE asset(id INTEGER PRIMARY KEY, medium TEXT)")
        writer.execute("CREATE TABLE asset_entity(asset_id INTEGER, entity_id INTEGER)")
        writer.execute("CREATE TABLE entity_alias(entity_id INTEGER, alias TEXT)")
        writer.execute("INSERT INTO entity VALUES(1,'studio','SOD Create')")
        writer.commit()
        self.module.time = type("clock", (), {
            "sleep": lambda _self, seconds: None,
            "monotonic": lambda _self: 0.0,
        })()

    def test_the_progress_line_cannot_take_the_batch_down(self):
        """入口块要把 stdout 换成 UTF-8:进度行里有日文标题,而本机控制台是 GBK。

        证据在 CSV 里(UTF-8),进度行糊掉无所谓;一个 print 把整批掉到一半才是代价。
        """
        source = (REPO / "scripts" / "harvest_studio_sites.py").read_text(encoding="utf-8")
        entry = source.split('if __name__ == "__main__":')[-1]
        self.assertIn('sys.stdout.reconfigure(encoding="utf-8", errors="replace")', entry)

    def test_the_confirmed_address_is_the_only_one_requested(self):
        import argparse
        asked: list[str] = []
        # 真实标题里那个 `・` 在 GBK 控制台上编不出来;`run()` 要打印标题,
        # 直调时没有入口块那句 `reconfigure`。这条测的是先试哪个地址,不拿它重现编码。
        title = "SOFT ON DEMAND(ソフトオンデマンド)"

        def probe(url, timeout, **kwargs):
            asked.append(url)
            return 200, page(title), url
        self.module.probe = probe
        args = argparse.Namespace(
            db=self.db, output=self.tmp / "out.csv", seeds=None,
            min_assets=3, only=["SOD Create"], interval=0.0, timeout=1.0, limit=0)
        self.assertEqual(run_script(self.module, args), 0)
        self.assertEqual(asked, ["https://www.sod.co.jp/"])
        from peach.review_csv import read_rows
        row = read_rows(self.tmp / "out.csv")[0]
        self.assertEqual(row["verdict"], "ok")
        self.assertEqual(row["final_url"], "https://www.sod.co.jp/")
        self.assertIn("用户", row["note"])


class AliasRunTests(unittest.TestCase):
    """别名要真的从账本走到判定里,不是只在 `site_verdict` 的参数上存在。"""

    def setUp(self):
        self.module = load_module()
        self.tmp = Path(tempfile.mkdtemp())
        self.db = self.tmp / "ledger.db"
        writer = sqlite3.connect(self.db)
        self.addCleanup(writer.close)
        writer.execute(
            "CREATE TABLE entity(id INTEGER PRIMARY KEY, kind TEXT, canonical_name TEXT)")
        writer.execute("CREATE TABLE asset(id INTEGER PRIMARY KEY, medium TEXT)")
        writer.execute("CREATE TABLE asset_entity(asset_id INTEGER, entity_id INTEGER)")
        writer.execute("CREATE TABLE entity_alias(entity_id INTEGER, alias TEXT)")
        writer.execute("INSERT INTO entity VALUES(1,'studio','东京热')")
        writer.executemany("INSERT INTO entity_alias VALUES(?,?)",
                           [(1, "东京热"), (1, "東京熱")])
        writer.commit()
        self.module.time = type("clock", (), {
            "sleep": lambda _self, seconds: None,
            "monotonic": lambda _self: 0.0,
        })()

    def test_a_seeded_site_is_confirmed_through_the_ledger_alias(self):
        """实测:账本规范名是简体「东京热」,`www.tokyo-hot.com` 的标题写的是「東京熱」。

        这家的域名推不出来(名字里没有拉丁字母),`--seeds` 是唯一入口;别名接不上的话,
        人工查到的地址取回 200 也只能写成未取得。规范名自己也登记在别名表里,判词不该
        因此写成「对上的是别名『东京热』」。
        """
        import argparse
        seeds = self.tmp / "seeds.csv"
        seeds.write_text("studio,site\n东京热,https://www.tokyo-hot.com/\n", encoding="utf-8")
        title = "年齢確認 | Tokyo-Hot 東京熱 無修正オリジナル徹底凌辱動画"
        self.module.probe = lambda url, timeout, **kwargs: (200, page(title), url)
        args = argparse.Namespace(
            db=self.db, output=self.tmp / "out.csv", seeds=seeds,
            min_assets=3, only=["东京热"], interval=0.0, timeout=1.0, limit=0)
        self.assertEqual(run_script(self.module, args), 0)
        from peach.review_csv import read_rows
        row = read_rows(self.tmp / "out.csv")[0]
        self.assertEqual(row["verdict"], "ok")
        self.assertEqual(row["final_url"], "https://www.tokyo-hot.com/")
        self.assertIn("東京熱", row["note"])
        self.assertNotIn("「东京热」", row["note"])


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