cli-web-reddit 0.1.0__py3-none-any.whl

cli_web/reddit/tests/test_e2e.py

@@ -0,0 +1,312 @@
+"""E2E live tests and subprocess tests for cli-web-reddit.
+
+These tests hit the real Reddit JSON API. No auth required (public read-only).
+"""
+
+from __future__ import annotations
+
+import json
+import os
+import shutil
+import subprocess
+import sys
+
+import pytest
+from cli_web.reddit.core.client import RedditClient
+
+# ── _resolve_cli helper ──────────────────────────────────────────
+
+
+def _resolve_cli(name):
+    """Resolve installed CLI command; falls back to python -m for dev."""
+    force = os.environ.get("CLI_WEB_FORCE_INSTALLED", "").strip() == "1"
+    path = shutil.which(name)
+    if path:
+        print(f"[_resolve_cli] Using installed command: {path}")
+        return [path]
+    if force:
+        raise RuntimeError(f"{name} not found in PATH. Install with: pip install -e .")
+    module = "cli_web.reddit.reddit_cli"
+    print(f"[_resolve_cli] Falling back to: {sys.executable} -m {module}")
+    return [sys.executable, "-m", module]
+
+
+# ── Helpers ──────────────────────────────────────────────────────
+
+
+def _posts_from_listing(data: dict) -> list[dict]:
+    """Extract post dicts from a Reddit listing response."""
+    return [child["data"] for child in data["data"]["children"]]
+
+
+def _assert_post_fields(post: dict) -> None:
+    """Verify a post dict has the required fields."""
+    for field in ("id", "title", "subreddit", "author", "score", "num_comments"):
+        assert field in post, f"Missing field: {field}"
+
+
+# ── Live API: Feed ───────────────────────────────────────────────
+
+
+@pytest.mark.live
+class TestFeedLive:
+    """Live tests for feed endpoints (no auth)."""
+
+    @pytest.fixture(autouse=True)
+    def setup_client(self):
+        self.client = RedditClient()
+        yield
+        self.client.close()
+
+    def test_feed_hot(self):
+        data = self.client.feed_hot(limit=3)
+        posts = _posts_from_listing(data)
+        assert len(posts) > 0
+        for p in posts:
+            _assert_post_fields(p)
+        print(f"[verify] feed_hot returned {len(posts)} posts, first: {posts[0]['title'][:60]}")
+
+    def test_feed_top(self):
+        data = self.client.feed_top(limit=3, time="day")
+        posts = _posts_from_listing(data)
+        assert len(posts) > 0
+        for p in posts:
+            _assert_post_fields(p)
+        print(f"[verify] feed_top returned {len(posts)} posts")
+
+    def test_feed_popular(self):
+        data = self.client.feed_popular(limit=3)
+        posts = _posts_from_listing(data)
+        assert len(posts) > 0
+        for p in posts:
+            _assert_post_fields(p)
+        print(f"[verify] feed_popular returned {len(posts)} posts")
+
+    def test_pagination(self):
+        """Fetch page 1, grab cursor, fetch page 2 — verify different posts."""
+        page1 = self.client.feed_hot(limit=3)
+        posts1 = _posts_from_listing(page1)
+        assert len(posts1) > 0
+
+        after = page1["data"].get("after")
+        assert after, "Expected pagination cursor in response"
+
+        page2 = self.client.feed_hot(limit=3, after=after)
+        posts2 = _posts_from_listing(page2)
+        assert len(posts2) > 0
+
+        ids1 = {p["id"] for p in posts1}
+        ids2 = {p["id"] for p in posts2}
+        assert ids1 != ids2, "Page 1 and page 2 should have different posts"
+        print(f"[verify] Pagination OK: page1 ids={ids1}, page2 ids={ids2}")
+
+
+# ── Live API: Subreddit ──────────────────────────────────────────
+
+
+@pytest.mark.live
+class TestSubredditLive:
+    """Live tests for subreddit endpoints."""
+
+    @pytest.fixture(autouse=True)
+    def setup_client(self):
+        self.client = RedditClient()
+        yield
+        self.client.close()
+
+    def test_sub_posts(self):
+        data = self.client.sub_posts("python", limit=3)
+        posts = _posts_from_listing(data)
+        assert len(posts) > 0
+        for p in posts:
+            _assert_post_fields(p)
+            assert p["subreddit"].lower() == "python"
+        print(f"[verify] r/python returned {len(posts)} posts")
+
+    def test_sub_info(self):
+        data = self.client.sub_info("python")
+        info = data["data"]
+        assert info["display_name"].lower() == "python"
+        assert "subscribers" in info
+        assert info["subscribers"] > 0
+        print(f"[verify] r/python: {info['subscribers']} subscribers")
+
+    def test_sub_rules(self):
+        data = self.client.sub_rules("python")
+        assert "rules" in data
+        rules = data["rules"]
+        assert len(rules) > 0
+        for rule in rules:
+            assert "short_name" in rule
+        print(f"[verify] r/python has {len(rules)} rules")
+
+    def test_list_get_roundtrip(self):
+        """List posts, then get one by ID via post_detail — verify fields match."""
+        listing = self.client.sub_posts("python", limit=3)
+        posts = _posts_from_listing(listing)
+        assert len(posts) > 0
+
+        target = posts[0]
+        post_id = target["id"]
+        subreddit = target["subreddit"]
+
+        detail = self.client.post_detail(subreddit, post_id)
+        assert isinstance(detail, list)
+        assert len(detail) >= 1
+        detail_post = detail[0]["data"]["children"][0]["data"]
+        assert detail_post["id"] == post_id
+        assert detail_post["title"] == target["title"]
+        print(f"[verify] Roundtrip OK: post {post_id} title matches")
+
+
+# ── Live API: Search ─────────────────────────────────────────────
+
+
+@pytest.mark.live
+class TestSearchLive:
+    """Live tests for search endpoints."""
+
+    @pytest.fixture(autouse=True)
+    def setup_client(self):
+        self.client = RedditClient()
+        yield
+        self.client.close()
+
+    def test_search_posts(self):
+        data = self.client.search_posts("python", limit=3)
+        posts = _posts_from_listing(data)
+        assert len(posts) > 0
+        for p in posts:
+            _assert_post_fields(p)
+        print(f"[verify] search_posts('python') returned {len(posts)} results")
+
+    def test_search_subreddits(self):
+        data = self.client.search_subreddits("python", limit=3)
+        subs = [child["data"] for child in data["data"]["children"]]
+        assert len(subs) > 0
+        for s in subs:
+            assert "display_name" in s
+        print(f"[verify] search_subreddits('python') returned {len(subs)} subreddits")
+
+
+# ── Live API: User ───────────────────────────────────────────────
+
+
+@pytest.mark.live
+class TestUserLive:
+    """Live tests for user endpoints."""
+
+    @pytest.fixture(autouse=True)
+    def setup_client(self):
+        self.client = RedditClient()
+        yield
+        self.client.close()
+
+    def test_user_about(self):
+        data = self.client.user_about("spez")
+        info = data["data"]
+        assert info["name"].lower() == "spez"
+        assert "link_karma" in info
+        print(f"[verify] u/spez: link_karma={info['link_karma']}")
+
+    def test_user_posts(self):
+        data = self.client.user_posts("spez", limit=3)
+        posts = _posts_from_listing(data)
+        assert len(posts) > 0
+        for p in posts:
+            assert p["author"].lower() == "spez"
+        print(f"[verify] u/spez has {len(posts)} posts returned")
+
+
+# ── Subprocess tests ─────────────────────────────────────────────
+
+
+@pytest.mark.subprocess
+class TestCLISubprocess:
+    """Test the CLI binary via subprocess (installed or python -m fallback)."""
+
+    @pytest.fixture(autouse=True)
+    def setup_cmd(self):
+        self.cmd = _resolve_cli("cli-web-reddit")
+
+    def _run(self, *args, check: bool = True) -> subprocess.CompletedProcess:
+        result = subprocess.run(
+            [*self.cmd, *args],
+            capture_output=True,
+            encoding="utf-8",
+            errors="replace",
+            timeout=60,
+        )
+        if check and result.returncode != 0:
+            print(f"[stderr] {result.stderr}")
+        return result
+
+    def test_help(self):
+        r = self._run("--help")
+        assert r.returncode == 0
+        out = r.stdout.lower()
+        assert "feed" in out
+        assert "sub" in out
+        assert "search" in out
+        assert "user" in out
+        print("[verify] --help lists all command groups")
+
+    def test_version(self):
+        r = self._run("--version")
+        assert r.returncode == 0
+        assert "0.2.0" in r.stdout
+        print(f"[verify] --version: {r.stdout.strip()}")
+
+    def test_feed_hot_json(self):
+        r = self._run("feed", "hot", "--limit", "3", "--json")
+        assert r.returncode == 0
+        data = json.loads(r.stdout)
+        assert "posts" in data or isinstance(data, list)
+        # Accept either {"posts": [...]} or [...] depending on output format
+        posts = data.get("posts", data) if isinstance(data, dict) else data
+        assert len(posts) > 0
+        print(f"[verify] feed hot --json returned {len(posts)} posts")
+
+    def test_search_posts_json(self):
+        r = self._run("search", "posts", "python", "--limit", "3", "--json")
+        assert r.returncode == 0
+        data = json.loads(r.stdout)
+        # Flexible: accept list or dict with posts key
+        if isinstance(data, dict):
+            posts = data.get("posts", data.get("results", []))
+        else:
+            posts = data
+        assert len(posts) > 0
+        print(f"[verify] search posts --json returned {len(posts)} results")
+
+    def test_sub_info_json(self):
+        r = self._run("sub", "info", "python", "--json")
+        assert r.returncode == 0
+        data = json.loads(r.stdout)
+        assert isinstance(data, dict)
+        # Should contain subreddit name field
+        name = data.get("display_name", data.get("name", ""))
+        assert name.lower() == "python"
+        print(f"[verify] sub info python --json: {name}")
+
+    def test_user_info_json(self):
+        r = self._run("user", "info", "spez", "--json")
+        assert r.returncode == 0
+        data = json.loads(r.stdout)
+        assert isinstance(data, dict)
+        name = data.get("name", "")
+        assert name.lower() == "spez"
+        print(f"[verify] user info spez --json: {name}")
+
+    def test_human_readable_output(self):
+        """Non-JSON output should produce human-readable table/text."""
+        r = self._run("feed", "hot", "--limit", "3")
+        assert r.returncode == 0
+        out = r.stdout
+        # Should have some text output, not raw JSON
+        assert len(out.strip()) > 0
+        # Should NOT start with '{' or '[' (not raw JSON)
+        stripped = out.strip()
+        assert not stripped.startswith("{"), "Expected human-readable output, got JSON"
+        assert not stripped.startswith("["), "Expected human-readable output, got JSON"
+        print(f"[verify] Human-readable output: {len(out)} chars")

cli_web/reddit/utils/doctor.py

@@ -0,0 +1,188 @@
+"""``doctor`` — self-diagnosis for cli-web-* CLIs.
+
+CANONICAL SOURCE: cli-web-core/cli_web_core/doctor.py
+Vendored into every generated CLI at cli_web/<app>/utils/doctor.py by
+`cli-web-devkit resync`. Do not edit vendored copies by hand.
+
+Checks the local environment a support thread would ask about first:
+installation, Python version, config directory, auth material (when the
+CLI has an auth module), and optional dependencies. Read-only — never
+mutates state, never touches the network.
+"""
+
+from __future__ import annotations
+
+import importlib.util
+import json
+import os
+import shutil
+import stat
+import sys
+from dataclasses import asdict, dataclass
+from pathlib import Path
+from typing import Any
+
+
+@dataclass
+class DoctorCheck:
+    name: str
+    status: str  # "ok" | "warn" | "fail"
+    detail: str = ""
+
+
+def _check_entry_point(app_name: str) -> DoctorCheck:
+    binary = f"cli-web-{app_name}"
+    path = shutil.which(binary)
+    if path:
+        return DoctorCheck("entry point", "ok", path)
+    return DoctorCheck(
+        "entry point",
+        "warn",
+        f"{binary} not on PATH — run `pip install -e .` in agent-harness/ "
+        f"(python -m fallback still works)",
+    )
+
+
+def _check_python() -> DoctorCheck:
+    # Intentional runtime guard: direct-source runs bypass pip's
+    # python_requires, so the interpreter check must live here.
+    if sys.version_info >= (3, 10):  # noqa: UP036
+        return DoctorCheck("python", "ok", sys.version.split()[0])
+    return DoctorCheck("python", "fail", f"{sys.version.split()[0]} < 3.10 (unsupported)")
+
+
+def _config_dir(app_name: str) -> Path:
+    return Path.home() / ".config" / f"cli-web-{app_name}"
+
+
+def _check_config_dir(app_name: str) -> DoctorCheck:
+    cfg = _config_dir(app_name)
+    if not cfg.exists():
+        return DoctorCheck("config dir", "ok", f"{cfg} (not created yet — created on first use)")
+    if os.access(cfg, os.W_OK):
+        return DoctorCheck("config dir", "ok", str(cfg))
+    return DoctorCheck("config dir", "fail", f"{cfg} is not writable")
+
+
+def _has_auth_module(pkg: str) -> bool:
+    try:
+        return importlib.util.find_spec(f"cli_web.{pkg}.core.auth") is not None
+    except (ImportError, ModuleNotFoundError, ValueError):
+        return False
+
+
+def _check_auth(app_name: str, pkg: str) -> list[DoctorCheck]:
+    if not _has_auth_module(pkg):
+        return [DoctorCheck("auth", "ok", "no auth module — public site, nothing to configure")]
+
+    checks: list[DoctorCheck] = []
+    if importlib.util.find_spec("playwright") is None:
+        checks.append(
+            DoctorCheck(
+                "playwright",
+                "warn",
+                "not installed — `auth login` (browser flow) unavailable; "
+                "pip install playwright && playwright install chromium",
+            )
+        )
+    else:
+        checks.append(DoctorCheck("playwright", "ok", "installed"))
+
+    env_var = f"CLI_WEB_{app_name.upper().replace('-', '_')}_AUTH_JSON"
+    if os.environ.get(env_var):
+        checks.append(DoctorCheck("auth source", "ok", f"using env var {env_var}"))
+        return checks
+
+    auth_file = _config_dir(app_name) / "auth.json"
+    if not auth_file.is_file():
+        checks.append(
+            DoctorCheck(
+                "auth file",
+                "warn",
+                f"{auth_file} missing — run: cli-web-{app_name} auth login (or set {env_var})",
+            )
+        )
+        return checks
+
+    checks.append(DoctorCheck("auth file", "ok", str(auth_file)))
+    if os.name == "posix":  # st_mode permission bits are meaningless on Windows
+        mode = stat.S_IMODE(auth_file.stat().st_mode)
+        if mode & 0o077:
+            checks.append(
+                DoctorCheck(
+                    "auth file permissions",
+                    "warn",
+                    f"{oct(mode)} — should be 600; run: chmod 600 {auth_file}",
+                )
+            )
+        else:
+            checks.append(DoctorCheck("auth file permissions", "ok", oct(mode)))
+    try:
+        json.loads(auth_file.read_text(encoding="utf-8"))
+        checks.append(DoctorCheck("auth file format", "ok", "valid JSON"))
+    except (OSError, json.JSONDecodeError) as exc:
+        checks.append(DoctorCheck("auth file format", "fail", f"unreadable: {exc}"))
+
+    return checks
+
+
+def _check_optional_deps() -> list[DoctorCheck]:
+    checks = []
+    if importlib.util.find_spec("prompt_toolkit") is None:
+        checks.append(
+            DoctorCheck("prompt_toolkit", "ok", "not installed — REPL uses plain input()")
+        )
+    else:
+        checks.append(DoctorCheck("prompt_toolkit", "ok", "installed (REPL autocomplete on)"))
+    return checks
+
+
+def run_doctor(app_name: str, pkg: str) -> list[DoctorCheck]:
+    checks = [
+        _check_python(),
+        _check_entry_point(app_name),
+        _check_config_dir(app_name),
+        *_check_auth(app_name, pkg),
+        *_check_optional_deps(),
+    ]
+    return checks
+
+
+def register_doctor_command(cli: Any, app_name: str, pkg: str | None = None) -> None:
+    """Attach a ``doctor`` command to a cli-web-* Click group."""
+    import click
+
+    resolved_pkg = pkg or app_name.replace("-", "_")
+
+    @cli.command("doctor")
+    @click.option("--json", "json_mode", is_flag=True, help="Output as JSON.")
+    @click.pass_context
+    def doctor(ctx: Any, json_mode: bool) -> None:
+        """Diagnose this CLI's local setup (install, auth, dependencies)."""
+        if not json_mode:  # honor the group-level --json flag (ctx.obj["json"])
+            obj = ctx.find_root().obj
+            json_mode = bool(obj.get("json")) if isinstance(obj, dict) else False
+        checks = run_doctor(app_name, resolved_pkg)
+        failed = [c for c in checks if c.status == "fail"]
+        if json_mode:
+            click.echo(
+                json.dumps(
+                    {
+                        "success": not failed,
+                        "data": {
+                            "checks": [asdict(c) for c in checks],
+                            "ok": not failed,
+                        },
+                    },
+                    indent=2,
+                )
+            )
+        else:
+            marks = {"ok": "✓", "warn": "⚠", "fail": "✗"}
+            for c in checks:
+                detail = f"  {c.detail}" if c.detail else ""
+                click.echo(f" {marks[c.status]} {c.name}:{detail}")
+            click.echo()
+            click.echo("all good" if not failed else f"{len(failed)} problem(s) found")
+        if failed:
+            raise SystemExit(1)

cli_web/reddit/utils/helpers.py

@@ -0,0 +1,91 @@
+"""Shared CLI helpers for cli-web-reddit."""
+
+from __future__ import annotations
+
+import json
+import sys
+from contextlib import contextmanager
+
+import click
+
+from ..core.exceptions import (
+    AuthError,
+    NetworkError,
+    NotFoundError,
+    RateLimitError,
+    RedditError,
+    ServerError,
+)
+
+
+def resolve_json_mode(json_mode: bool) -> bool:
+    """Honor explicit --json or inherit it from the root CLI context."""
+    if json_mode:
+        return True
+    ctx = click.get_current_context(silent=True)
+    root = ctx.find_root() if ctx else None
+    if root and isinstance(root.obj, dict):
+        return bool(root.obj.get("json", False))
+    return False
+
+
+def json_error(code: str, message: str, **extra) -> str:
+    """Format an error as JSON string."""
+    return json.dumps({"error": True, "code": code, "message": message, **extra})
+
+
+@contextmanager
+def handle_errors(json_mode: bool = False):
+    """Context manager for consistent error handling across all commands."""
+    try:
+        yield
+    except AuthError as exc:
+        if json_mode:
+            click.echo(json_error("AUTH_EXPIRED", str(exc)))
+        else:
+            click.echo(f"Error: {exc}", err=True)
+        sys.exit(1)
+    except NotFoundError as exc:
+        if json_mode:
+            click.echo(json_error("NOT_FOUND", str(exc)))
+        else:
+            click.echo(f"Error: {exc}", err=True)
+        sys.exit(1)
+    except RateLimitError as exc:
+        if json_mode:
+            click.echo(json_error("RATE_LIMITED", str(exc), retry_after=exc.retry_after))
+        else:
+            click.echo(f"Error: {exc}", err=True)
+        sys.exit(1)
+    except ServerError as exc:
+        if json_mode:
+            click.echo(json_error("SERVER_ERROR", str(exc)))
+        else:
+            click.echo(f"Error: {exc}", err=True)
+        sys.exit(2)
+    except NetworkError as exc:
+        if json_mode:
+            click.echo(json_error("NETWORK_ERROR", str(exc)))
+        else:
+            click.echo(f"Error: {exc}", err=True)
+        sys.exit(2)
+    except RedditError as exc:
+        if json_mode:
+            click.echo(json_error("ERROR", str(exc)))
+        else:
+            click.echo(f"Error: {exc}", err=True)
+        sys.exit(1)
+    except KeyboardInterrupt:
+        sys.exit(130)
+
+
+def print_json(data) -> None:
+    """Print data as formatted JSON."""
+    click.echo(json.dumps(data, indent=2, ensure_ascii=False))
+
+
+def truncate(text: str | None, length: int = 50) -> str:
+    """Truncate text to a maximum length."""
+    if not text:
+        return ""
+    return text[:length] + "..." if len(text) > length else text