cli-web-amazon 0.1.1__py3-none-any.whl

cli_web/amazon/tests/test_e2e.py

@@ -0,0 +1,355 @@
+"""E2E and subprocess tests for cli-web-amazon."""
+
+import json
+import os
+import shutil
+import subprocess
+import sys
+
+import pytest
+
+# ---------------------------------------------------------------------------
+# _resolve_cli helper
+# ---------------------------------------------------------------------------
+
+
+def _resolve_cli(name: str):
+    """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:
+        return [path]
+    if force:
+        raise RuntimeError(f"{name} not found in PATH. Install with: pip install -e .")
+    module = name.replace("cli-web-", "cli_web.") + "." + name.split("-")[-1] + "_cli"
+    return [sys.executable, "-m", module]
+
+
+CLI = _resolve_cli("cli-web-amazon")
+
+
+# ---------------------------------------------------------------------------
+# Live E2E — public commands (no auth required)
+# ---------------------------------------------------------------------------
+
+
+@pytest.mark.e2e
+class TestE2ESuggest:
+    """cli-web-amazon suggest — live autocomplete API."""
+
+    def test_suggest_returns_results(self):
+        from cli_web.amazon.core.client import AmazonClient
+
+        with AmazonClient() as client:
+            suggestions = client.get_suggestions("laptop")
+        assert len(suggestions) > 0, "Suggest returned empty list for 'laptop'"
+        assert suggestions[0].value, "First suggestion has no value"
+        assert suggestions[0].type, "First suggestion has no type"
+
+    def test_suggest_keyword_type(self):
+        from cli_web.amazon.core.client import AmazonClient
+
+        with AmazonClient() as client:
+            suggestions = client.get_suggestions("headphones")
+        types = {s.type for s in suggestions}
+        assert "KEYWORD" in types, f"Expected KEYWORD type in suggestions; got: {types}"
+
+    def test_suggest_no_rpc_leakage(self):
+        from cli_web.amazon.core.client import AmazonClient
+
+        with AmazonClient() as client:
+            suggestions = client.get_suggestions("phone")
+        for s in suggestions:
+            assert "wrb.fr" not in s.value, "Raw RPC data leaked into suggestion"
+            assert "af.httprm" not in s.value, "Raw RPC data leaked into suggestion"
+
+    def test_suggest_unusual_query_returns_list(self):
+        from cli_web.amazon.core.client import AmazonClient
+
+        with AmazonClient() as client:
+            suggestions = client.get_suggestions("xyzzy12345noresults")
+        # May return empty list — just must not raise
+        assert isinstance(suggestions, list)
+
+
+@pytest.mark.e2e
+class TestE2ESearch:
+    """cli-web-amazon search — live HTML search."""
+
+    def test_search_returns_asins(self):
+        from cli_web.amazon.core.client import AmazonClient
+
+        with AmazonClient() as client:
+            results = client.search("laptop")
+        assert len(results) > 0, "Search returned no results for 'laptop'"
+        for r in results:
+            assert len(r.asin) == 10, f"ASIN {r.asin!r} does not look like a valid ASIN"
+
+    def test_search_result_fields(self):
+        from cli_web.amazon.core.client import AmazonClient
+
+        with AmazonClient() as client:
+            results = client.search("laptop")
+        first = results[0]
+        assert first.title, "First search result has no title"
+        assert first.url.startswith("https://www.amazon.com"), f"URL looks wrong: {first.url}"
+
+    def test_search_url_uses_asin(self):
+        from cli_web.amazon.core.client import AmazonClient
+
+        with AmazonClient() as client:
+            results = client.search("laptop")
+        first = results[0]
+        assert first.asin in first.url, "ASIN not present in product URL"
+
+    def test_search_pagination(self):
+        from cli_web.amazon.core.client import AmazonClient
+
+        with AmazonClient() as client:
+            page1 = client.search("laptop", page=1)
+            page2 = client.search("laptop", page=2)
+        # Both pages should have results; they should not be identical
+        assert len(page1) > 0
+        assert len(page2) > 0
+        asin1 = {r.asin for r in page1}
+        asin2 = {r.asin for r in page2}
+        assert asin1 != asin2, "Page 1 and page 2 returned identical ASINs"
+
+    def test_search_no_rpc_leakage(self):
+        from cli_web.amazon.core.client import AmazonClient
+
+        with AmazonClient() as client:
+            results = client.search("laptop")
+        for r in results:
+            assert "wrb.fr" not in r.title, "Raw RPC data in search title"
+
+
+@pytest.mark.e2e
+class TestE2EProduct:
+    """cli-web-amazon product get — live product detail page."""
+
+    KNOWN_ASIN = "B0GRZ78683"  # Dell Inspiron 15 (stable listing)
+
+    def test_get_product_returns_data(self):
+        from cli_web.amazon.core.client import AmazonClient
+
+        with AmazonClient() as client:
+            product = client.get_product(self.KNOWN_ASIN)
+        assert product.asin == self.KNOWN_ASIN
+        assert product.title, "Product title is empty"
+        assert len(product.title) > 10, "Product title suspiciously short"
+
+    def test_get_product_url_is_dp_url(self):
+        from cli_web.amazon.core.client import AmazonClient
+
+        with AmazonClient() as client:
+            product = client.get_product(self.KNOWN_ASIN)
+        assert self.KNOWN_ASIN in product.url, "ASIN not in product URL"
+        assert product.url.startswith("https://www.amazon.com"), "URL doesn't start with amazon.com"
+
+    def test_get_product_rating_format(self):
+        from cli_web.amazon.core.client import AmazonClient
+
+        with AmazonClient() as client:
+            product = client.get_product(self.KNOWN_ASIN)
+        if product.rating:
+            assert "out of 5" in product.rating, f"Unexpected rating format: {product.rating}"
+
+    def test_search_then_get_round_trip(self):
+        """Search → pick first ASIN → get product → verify title matches."""
+        from cli_web.amazon.core.client import AmazonClient
+
+        with AmazonClient() as client:
+            results = client.search("laptop")
+            assert len(results) > 0
+            asin = results[0].asin
+            product = client.get_product(asin)
+        assert product.asin == asin, "Product ASIN mismatch"
+        assert product.title, "Product returned by get has no title"
+
+    def test_get_product_no_rpc_leakage(self):
+        from cli_web.amazon.core.client import AmazonClient
+
+        with AmazonClient() as client:
+            product = client.get_product(self.KNOWN_ASIN)
+        assert "wrb.fr" not in product.title, "Raw RPC data in product title"
+        assert "af.httprm" not in (product.title + str(product.price)), "Raw RPC data in product"
+
+
+@pytest.mark.e2e
+class TestE2EBestSellers:
+    """cli-web-amazon bestsellers — live bestseller page."""
+
+    def test_bestsellers_electronics(self):
+        from cli_web.amazon.core.client import AmazonClient
+
+        with AmazonClient() as client:
+            items = client.get_bestsellers("electronics")
+        assert len(items) > 0, "Bestsellers returned no items for electronics"
+        assert items[0].rank == 1, f"First item rank should be 1, got {items[0].rank}"
+
+    def test_bestsellers_asin_length(self):
+        from cli_web.amazon.core.client import AmazonClient
+
+        with AmazonClient() as client:
+            items = client.get_bestsellers("electronics")
+        for item in items:
+            assert len(item.asin) == 10, f"ASIN {item.asin!r} not 10 chars"
+
+    def test_bestsellers_rank_sequential(self):
+        from cli_web.amazon.core.client import AmazonClient
+
+        with AmazonClient() as client:
+            items = client.get_bestsellers("electronics")
+        ranks = [i.rank for i in items]
+        assert ranks == sorted(ranks), "Ranks are not in ascending order"
+        assert ranks[0] == 1, "First rank is not 1"
+
+    def test_bestsellers_title_not_empty(self):
+        from cli_web.amazon.core.client import AmazonClient
+
+        with AmazonClient() as client:
+            items = client.get_bestsellers("books")
+        for item in items:
+            assert item.title, f"Item with ASIN {item.asin} has empty title"
+
+    def test_bestsellers_url_contains_asin(self):
+        from cli_web.amazon.core.client import AmazonClient
+
+        with AmazonClient() as client:
+            items = client.get_bestsellers("electronics")
+        for item in items:
+            assert item.asin in item.url, f"ASIN {item.asin} not in URL {item.url}"
+
+
+# ---------------------------------------------------------------------------
+# Subprocess tests — full CLI invocations
+# ---------------------------------------------------------------------------
+
+
+@pytest.mark.e2e
+class TestCLISubprocess:
+    """End-to-end subprocess tests using the installed cli-web-amazon binary."""
+
+    def _run(self, args, check=False):
+        return subprocess.run(
+            CLI + args,
+            capture_output=True,
+            text=True,
+            encoding="utf-8",
+            errors="replace",
+            check=check,
+        )
+
+    def test_help_loads(self):
+        result = self._run(["--help"])
+        assert result.returncode == 0
+        assert "cli-web-amazon" in result.stdout.lower() or "amazon" in result.stdout.lower()
+
+    def test_version(self):
+        result = self._run(["--version"])
+        assert result.returncode == 0
+
+    def test_search_json_output(self):
+        result = self._run(["search", "laptop", "--json"])
+        assert result.returncode == 0, f"stderr: {result.stderr}"
+        data = json.loads(result.stdout)
+        assert isinstance(data, list), "Expected JSON array"
+        assert len(data) > 0, "Search returned empty list"
+        first = data[0]
+        assert "asin" in first
+        assert "title" in first
+        assert len(first["asin"]) == 10, "ASIN not 10 chars"
+
+    def test_search_no_rpc_leak(self):
+        result = self._run(["search", "laptop", "--json"])
+        assert result.returncode == 0
+        data = json.loads(result.stdout)
+        for item in data:
+            assert "wrb.fr" not in item.get("title", ""), "Raw RPC data in title"
+            assert "af.httprm" not in item.get("title", ""), "Raw RPC data in title"
+
+    def test_suggest_json_output(self):
+        result = self._run(["suggest", "laptop", "--json"])
+        assert result.returncode == 0, f"stderr: {result.stderr}"
+        data = json.loads(result.stdout)
+        assert isinstance(data, list)
+        assert len(data) > 0
+        assert "value" in data[0]
+        assert "type" in data[0]
+
+    def test_product_get_json_output(self):
+        result = self._run(["product", "get", "B0GRZ78683", "--json"])
+        assert result.returncode == 0, f"stderr: {result.stderr}"
+        data = json.loads(result.stdout)
+        assert data["asin"] == "B0GRZ78683"
+        assert data["title"], "Product title is empty"
+        assert "url" in data
+        assert "B0GRZ78683" in data["url"]
+
+    def test_product_get_no_rpc_leak(self):
+        result = self._run(["product", "get", "B0GRZ78683", "--json"])
+        assert result.returncode == 0
+        data = json.loads(result.stdout)
+        assert "wrb.fr" not in data.get("title", ""), "Raw RPC data in product title"
+
+    def test_bestsellers_json_output(self):
+        result = self._run(["bestsellers", "electronics", "--json"])
+        assert result.returncode == 0, f"stderr: {result.stderr}"
+        data = json.loads(result.stdout)
+        assert isinstance(data, list)
+        assert len(data) > 0
+        assert data[0]["rank"] == 1
+
+    def test_bestsellers_required_fields(self):
+        result = self._run(["bestsellers", "electronics", "--json"])
+        assert result.returncode == 0
+        data = json.loads(result.stdout)
+        for item in data:
+            assert "asin" in item
+            assert "title" in item
+            assert "rank" in item
+
+    def test_search_with_page(self):
+        result = self._run(["search", "laptop", "--page", "2", "--json"])
+        assert result.returncode == 0, f"stderr: {result.stderr}"
+        data = json.loads(result.stdout)
+        assert isinstance(data, list)
+
+    def test_search_with_dept(self):
+        result = self._run(["search", "laptop", "--dept", "electronics", "--json"])
+        assert result.returncode == 0, f"stderr: {result.stderr}"
+        data = json.loads(result.stdout)
+        assert isinstance(data, list)
+
+    def test_product_get_unknown_asin_error(self):
+        """Unknown ASIN should return a structured error, not a crash."""
+        result = self._run(["product", "get", "BADASIN000", "--json"])
+        # May return error or empty product — should not crash
+        if result.returncode != 0:
+            try:
+                data = json.loads(result.stdout)
+                assert "error" in data
+            except json.JSONDecodeError:
+                pytest.fail("CLI crashed with non-JSON output on unknown ASIN")
+
+    def test_search_help_subcommand(self):
+        result = self._run(["search", "--help"])
+        assert result.returncode == 0
+        assert "search" in result.stdout.lower()
+
+    def test_product_help_subcommand(self):
+        result = self._run(["product", "--help"])
+        assert result.returncode == 0
+
+    def test_bestsellers_help_subcommand(self):
+        result = self._run(["bestsellers", "--help"])
+        assert result.returncode == 0
+
+    def test_suggest_help_subcommand(self):
+        result = self._run(["suggest", "--help"])
+        assert result.returncode == 0
+
+
+if __name__ == "__main__":
+    pytest.main([__file__, "-v"])

cli_web/amazon/utils/__init__.py

@@ -0,0 +1 @@
+"""Utilities for cli-web-amazon."""

cli_web/amazon/utils/config.py

@@ -0,0 +1,5 @@
+"""Configuration helpers for cli-web-amazon."""
+
+from pathlib import Path
+
+CONFIG_DIR = Path.home() / ".config" / "cli-web-amazon"

cli_web/amazon/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/amazon/utils/helpers.py

@@ -0,0 +1,127 @@
+"""Shared CLI helpers for cli-web-amazon."""
+
+import json
+import sys
+from contextlib import contextmanager
+from pathlib import Path
+from typing import Any
+
+import click
+
+from ..core.exceptions import (
+    AmazonError,
+    ParsingError,
+    RateLimitError,
+    error_code_for,
+)
+
+CONFIG_DIR = Path.home() / ".config" / "cli-web-amazon"
+CONFIG_FILE = CONFIG_DIR / "config.json"
+
+
+# ---------------------------------------------------------------------------
+# JSON output helper
+# ---------------------------------------------------------------------------
+
+
+def print_json(data: Any) -> None:
+    """Print data as pretty JSON."""
+    click.echo(json.dumps(data, ensure_ascii=False, indent=2))
+
+
+# ---------------------------------------------------------------------------
+# Error handler context manager
+# ---------------------------------------------------------------------------
+
+
+@contextmanager
+def handle_errors(json_mode: bool = False):
+    """Context manager that catches exceptions and outputs proper error messages.
+
+    Exit codes: 1=user/app error, 2=system error, 130=keyboard interrupt.
+    """
+    try:
+        yield
+    except KeyboardInterrupt:
+        if not json_mode:
+            click.echo("\nInterrupted.", err=True)
+        sys.exit(130)
+    except click.exceptions.Exit:
+        raise
+    except click.UsageError:
+        raise
+    except AmazonError as exc:
+        code = error_code_for(exc)
+        if json_mode:
+            err_dict: dict = {"error": True, "code": code, "message": str(exc)}
+            if isinstance(exc, RateLimitError) and exc.retry_after is not None:
+                err_dict["retry_after"] = exc.retry_after
+            click.echo(json.dumps(err_dict, ensure_ascii=False))
+        else:
+            hint = ""
+            if isinstance(exc, RateLimitError) and exc.retry_after:
+                hint = f"\n  Hint: Retry after {exc.retry_after:.0f}s"
+            elif isinstance(exc, ParsingError):
+                hint = "\n  Hint: Amazon page structure may have changed"
+            click.echo(f"Error: {exc}{hint}", err=True)
+        sys.exit(1)
+    except Exception as exc:
+        if json_mode:
+            click.echo(
+                json.dumps(
+                    {"error": True, "code": "INTERNAL_ERROR", "message": str(exc)},
+                    ensure_ascii=False,
+                )
+            )
+        else:
+            click.echo(f"Error: {exc}", err=True)
+        sys.exit(2)
+
+
+# ---------------------------------------------------------------------------
+# Filename sanitization
+# ---------------------------------------------------------------------------
+
+_INVALID_CHARS = set('/\\:*?"<>|')
+
+
+def sanitize_filename(name: str, max_length: int = 240) -> str:
+    """Convert a title to a safe filename."""
+    if not name or not name.strip():
+        return "untitled"
+    safe = "".join(c if c not in _INVALID_CHARS else "_" for c in name)
+    safe = safe.strip(". ")
+    return safe[:max_length] if safe else "untitled"
+
+
+# ---------------------------------------------------------------------------
+# Persistent config
+# ---------------------------------------------------------------------------
+
+
+def _load_config() -> dict:
+    """Load config.json, returning empty dict on failure."""
+    try:
+        if CONFIG_FILE.exists():
+            return json.loads(CONFIG_FILE.read_text(encoding="utf-8"))
+    except (json.JSONDecodeError, OSError):
+        pass
+    return {}
+
+
+def _save_config(data: dict) -> None:
+    """Save config.json."""
+    CONFIG_DIR.mkdir(parents=True, exist_ok=True)
+    CONFIG_FILE.write_text(json.dumps(data, indent=2), encoding="utf-8")
+
+
+def get_config_value(key: str) -> Any:
+    """Get a value from persistent config."""
+    return _load_config().get(key)
+
+
+def set_config_value(key: str, value: Any) -> None:
+    """Set a value in persistent config."""
+    cfg = _load_config()
+    cfg[key] = value
+    _save_config(cfg)