daily-robots/tests/test_featured_resolve.py

# tests/test_featured_resolve.py
from __future__ import annotations

import json
import random
import tempfile
import unittest
from pathlib import Path
from unittest.mock import patch

from daily.featured_pick import (
    featured_identity_key,
    featured_resolve,
    load_recent_featured_keys,
    load_yesterday_featured_key,
)


class FeaturedResolveTests(unittest.TestCase):
    def test_same_as_yesterday_picks_from_pool_a(self):
        yesterday_key = "headroomlabs-ai/headroom"
        pool_a = [
            {"repo": "headroomlabs-ai/headroom", "board": "github_topic"},
            {"repo": "ollama/ollama", "board": "github_trending"},
        ]
        rng = random.Random(0)
        resolved, key = featured_resolve(
            date_str="2026-07-14",
            candidate={
                "type": "github",
                "url": "https://github.com/headroomlabs-ai/headroom",
                "title": "headroom",
            },
            pool_a=pool_a,
            pool_b=[],
            recent_featured={yesterday_key},
            yesterday_key=yesterday_key,
            rng=rng,
        )
        self.assertNotEqual(key, yesterday_key)
        self.assertEqual(key, "ollama/ollama")
        self.assertIsNotNone(resolved)
        assert resolved is not None
        self.assertEqual(resolved.get("repo"), "ollama/ollama")

    def test_pool_a_before_pool_b(self):
        yesterday_key = "blocked/one"
        pool_a = [{"repo": "pool-a/repo", "board": "github_trending"}]
        pool_b = [{"repo": "pool-b/repo", "board": "github_emerging"}]
        resolved, key = featured_resolve(
            date_str="2026-07-14",
            candidate={"type": "github", "repo": "blocked/one", "title": "one"},
            pool_a=pool_a,
            pool_b=pool_b,
            recent_featured={yesterday_key},
            yesterday_key=yesterday_key,
            rng=random.Random(1),
        )
        self.assertEqual(key, "pool-a/repo")
        assert resolved is not None
        self.assertEqual(resolved.get("repo"), "pool-a/repo")

    def test_exhausted_keeps_original(self):
        yesterday_key = "only/one"
        candidate = {"type": "github", "repo": "only/one", "title": "one"}
        resolved, key = featured_resolve(
            date_str="2026-07-14",
            candidate=candidate,
            pool_a=[{"repo": "only/one", "board": "github_trending"}],
            pool_b=[],
            recent_featured={yesterday_key},
            yesterday_key=yesterday_key,
            rng=random.Random(2),
        )
        self.assertEqual(key, yesterday_key)
        self.assertEqual(resolved, candidate)

    def test_identity_key_skill_and_github(self):
        self.assertEqual(
            featured_identity_key({"type": "skill", "id": "a/b/c"}),
            "a/b/c",
        )
        self.assertEqual(
            featured_identity_key(
                {"type": "github", "url": "https://github.com/foo/bar"}
            ),
            "foo/bar",
        )

    def test_load_yesterday_falls_back_to_featured_pick(self):
        """缺 featured_pick_key 时从 featured_pick.url 推导身份，避免连日重复首推。"""
        with tempfile.TemporaryDirectory() as tmp:
            out = Path(tmp)
            payload = {
                "data": {
                    "date": "2026-07-13",
                    "featured_pick": {
                        "type": "github",
                        "title": "headroom",
                        "url": "https://github.com/headroomlabs-ai/headroom",
                    },
                }
            }
            (out / "2026-07-13.data.json").write_text(
                json.dumps(payload, ensure_ascii=False), encoding="utf-8"
            )
            with patch("daily.featured_pick.OUTPUT_DIR", out):
                key = load_yesterday_featured_key("2026-07-14")
            self.assertEqual(key, "headroomlabs-ai/headroom")

    def test_load_recent_falls_back_to_featured_pick(self):
        with tempfile.TemporaryDirectory() as tmp:
            out = Path(tmp)
            payload = {
                "data": {
                    "date": "2026-07-13",
                    "featured_pick": {
                        "type": "github",
                        "url": "https://github.com/headroomlabs-ai/headroom",
                    },
                }
            }
            (out / "2026-07-13.data.json").write_text(
                json.dumps(payload, ensure_ascii=False), encoding="utf-8"
            )
            with patch("daily.featured_pick.OUTPUT_DIR", out):
                keys = load_recent_featured_keys("2026-07-14", days=7)
            self.assertIn("headroomlabs-ai/headroom", keys)


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