procesio-cli 0.1.1__py3-none-any.whl

procesio_cli/tools/web/tests/test_dispatch.py

@@ -0,0 +1,132 @@
+"""Dispatcher: action routing, arg parsing, driver injection vs not, and the
+--actions / --actions-file handling in the run handler."""
+from __future__ import annotations
+
+import json
+
+import pytest
+
+from tools.web import main, sessions
+from tools.web.errors import UsageError
+
+
+def _seed(name="linkedin"):
+    sessions.write_state(name, {"cookies": [{"name": "sid", "value": "v"}], "origins": []})
+
+
+def test_unknown_action_raises_usage_error():
+    with pytest.raises(UsageError) as e:
+        main.dispatch("frobnicate", [])
+    assert "unknown action" in str(e.value)
+
+
+def test_all_manifest_actions_registered():
+    # every advertised action exists in the dispatcher
+    for name in ["save-session", "list-sessions", "delete-session",
+                 "run", "get-text", "screenshot"]:
+        assert name in main.ACTIONS
+
+
+def test_list_sessions_needs_no_driver(isolated_sessions):
+    _seed("a")
+    out = main.dispatch("list-sessions", [])
+    assert out["count"] == 1
+    assert out["sessions"][0]["name"] == "a"
+
+
+def test_delete_session_dispatch_requires_confirm(isolated_sessions):
+    _seed("gone")
+    preview = main.dispatch("delete-session", ["--name", "gone"])
+    assert preview["deleted"] is False and preview["confirmation_required"] is True
+
+    out = main.dispatch("delete-session", ["--name", "gone", "--confirm"])
+    assert out["deleted"] is True and out["removed"] == ["state"]
+
+
+def test_run_dispatch_injects_driver(isolated_sessions, driver_factory):
+    _seed()
+    steps = [{"do": "extract_text", "selector": "h1", "name": "t"}]
+    out = main.dispatch(
+        "run",
+        ["--session", "linkedin", "--actions", json.dumps(steps)],
+        driver_factory=driver_factory,
+    )
+    assert out["session"] == "linkedin"
+    assert "t" in out["results"]
+    assert driver_factory.built  # a driver was built and injected
+
+
+def test_run_headed_flag(isolated_sessions, driver_factory):
+    _seed()
+    main.dispatch(
+        "run",
+        ["--session", "linkedin", "--actions", "[]", "--headed"],
+        driver_factory=driver_factory,
+    )
+    assert driver_factory.built[0].init["headless"] is False
+
+
+def test_run_actions_file(isolated_sessions, driver_factory, tmp_path):
+    _seed()
+    f = tmp_path / "steps.json"
+    f.write_text(json.dumps([{"do": "goto", "url": "https://x.test"}]), encoding="utf-8")
+    out = main.dispatch(
+        "run",
+        ["--session", "linkedin", "--actions-file", str(f)],
+        driver_factory=driver_factory,
+    )
+    assert "goto" in driver_factory.built[0].methods()
+    assert out["session"] == "linkedin"
+
+
+def test_run_both_actions_and_file_rejected(isolated_sessions, driver_factory, tmp_path):
+    _seed()
+    f = tmp_path / "s.json"
+    f.write_text("[]", encoding="utf-8")
+    with pytest.raises(UsageError):
+        main.dispatch(
+            "run",
+            ["--session", "linkedin", "--actions", "[]", "--actions-file", str(f)],
+            driver_factory=driver_factory,
+        )
+
+
+def test_run_missing_actions_rejected(isolated_sessions, driver_factory):
+    _seed()
+    with pytest.raises(UsageError):
+        main.dispatch("run", ["--session", "linkedin"], driver_factory=driver_factory)
+
+
+def test_run_bad_json_rejected(isolated_sessions, driver_factory):
+    _seed()
+    with pytest.raises(UsageError):
+        main.dispatch("run", ["--session", "linkedin", "--actions", "{not json"],
+                      driver_factory=driver_factory)
+
+
+def test_get_text_dispatch(isolated_sessions, driver_factory):
+    _seed()
+    out = main.dispatch(
+        "get-text",
+        ["--session", "linkedin", "--url", "https://x.test", "--selector", "main"],
+        driver_factory=driver_factory,
+    )
+    assert out["selector"] == "main"
+    assert out["url"] == "https://x.test"
+
+
+def test_screenshot_dispatch(isolated_sessions, driver_factory, tmp_path):
+    _seed()
+    out = main.dispatch(
+        "screenshot",
+        ["--session", "linkedin", "--url", "https://x.test",
+         "--out", str(tmp_path / "s.png")],
+        driver_factory=driver_factory,
+    )
+    assert out["path"].endswith("s.png")
+
+
+def test_missing_required_arg_raises_usage_error(isolated_sessions, driver_factory):
+    with pytest.raises(UsageError):
+        main.dispatch("get-text", ["--session", "linkedin"],
+                      driver_factory=driver_factory)  # missing --url

procesio_cli/tools/web/tests/test_errors.py

@@ -0,0 +1,60 @@
+"""Error classification -> framework envelope (code, message, details, exit)."""
+from __future__ import annotations
+
+from tools.web.errors import (
+    BrowserError,
+    SessionError,
+    UsageError,
+    classify,
+)
+
+
+def test_usage_error_maps_to_invalid_argument_exit_2():
+    code, msg, details, exit_code = classify(UsageError("bad arg"))
+    assert code == "invalid_argument"
+    assert exit_code == 2
+    assert msg == "bad arg"
+
+
+def test_session_error_maps_to_session_not_found():
+    code, msg, details, exit_code = classify(SessionError("no session"))
+    assert code == "session_not_found"
+    assert exit_code == 1
+
+
+def test_browser_error_carries_details():
+    code, msg, details, exit_code = classify(
+        BrowserError("nav timeout", {"url": "https://x"})
+    )
+    assert code == "browser_error"
+    assert exit_code == 1
+    assert details == {"url": "https://x"}
+
+
+def test_generic_exception_maps_to_error():
+    code, msg, details, exit_code = classify(RuntimeError("boom"))
+    assert code == "error"
+    assert exit_code == 1
+    assert msg == "boom"
+
+
+def test_empty_message_falls_back_to_class_name():
+    code, msg, _details, _exit = classify(ValueError())
+    assert code == "error"
+    assert msg == "ValueError"
+
+
+class _FakePlaywrightTimeout(Exception):
+    pass
+
+
+_FakePlaywrightTimeout.__module__ = "playwright._impl._errors"
+_FakePlaywrightTimeout.__name__ = "TimeoutError"
+
+
+def test_playwright_error_classname_maps_to_browser_error():
+    # Simulate a raw playwright error reaching classify without our wrapper.
+    exc = _FakePlaywrightTimeout("Timeout 30000ms exceeded")
+    code, msg, _details, exit_code = classify(exc)
+    assert code == "browser_error"
+    assert exit_code == 1

procesio_cli/tools/web/tests/test_manifest_sync.py

@@ -0,0 +1,76 @@
+"""Guard: tool.yaml must declare exactly the actions the dispatcher registers,
+and every CLI flag must appear as a manifest arg (and vice-versa). Keeps the
+manifest (source of truth) from drifting away from the runtime."""
+from __future__ import annotations
+
+from pathlib import Path
+
+from tools._lib.manifest import load_tool
+from tools.web import main
+
+
+def _manifest():
+    tool_root = Path(main.__file__).resolve().parent
+    return load_tool(tool_root / "tool.yaml")
+
+
+def test_manifest_loads():
+    m = _manifest()
+    assert m.name == "web"
+
+
+def test_manifest_actions_match_dispatch():
+    m = _manifest()
+    manifest_actions = set(m.action_names())
+    dispatch_actions = set(main.ACTIONS)
+    assert manifest_actions == dispatch_actions, (
+        f"only in manifest: {manifest_actions - dispatch_actions}; "
+        f"only in code: {dispatch_actions - manifest_actions}"
+    )
+
+
+def test_manifest_args_match_argparse():
+    import argparse
+
+    m = _manifest()
+    for name, defn in main.ACTIONS.items():
+        parser = argparse.ArgumentParser()
+        defn.add_args(parser)
+        argparse_names = set()
+        for action in parser._actions:
+            for opt in action.option_strings:
+                if opt.startswith("--") and opt != "--help":
+                    argparse_names.add(opt[2:])
+        spec = m.get_action(name)
+        manifest_names = {a.name for a in spec.args}
+        assert manifest_names == argparse_names, (
+            f"action {name}: only in manifest {manifest_names - argparse_names}; "
+            f"only in argparse {argparse_names - manifest_names}"
+        )
+
+
+def test_required_args_marked_required_in_manifest():
+    import argparse
+
+    m = _manifest()
+    for name, defn in main.ACTIONS.items():
+        parser = argparse.ArgumentParser()
+        defn.add_args(parser)
+        required_argparse = set()
+        for action in parser._actions:
+            if getattr(action, "required", False):
+                for opt in action.option_strings:
+                    if opt.startswith("--"):
+                        required_argparse.add(opt[2:])
+        spec = m.get_action(name)
+        required_manifest = {a.name for a in spec.args if a.required}
+        assert required_argparse <= required_manifest, (
+            f"action {name}: argparse-required but not manifest-required: "
+            f"{required_argparse - required_manifest}"
+        )
+
+
+def test_no_secrets_declared():
+    # web stores auth in gitignored session files, not Credential Manager.
+    m = _manifest()
+    assert m.secrets == []

procesio_cli/tools/web/tests/test_page_contacts.py

@@ -0,0 +1,68 @@
+"""page-contacts: one plain GET -> published emails, profile and affiliate links."""
+from __future__ import annotations
+
+import pytest
+
+from tools.web import main as web_main
+from tools.web.errors import UsageError
+from tools.web.handlers import contacts as page
+
+LINKTREE = """<!DOCTYPE html><html><head><title>@jane | Linktree</title></head><body>
+<a href="https://www.linkedin.com/in/jane-doe">LinkedIn</a>
+<a href="https://acme.partnerlinks.io/jane">The tool I use</a>
+<a href="mailto:jane@studio.io">Email</a>
+<script id="__NEXT_DATA__">{"socials":[{"url":"https:\\/\\/x.com\\/janedoe"}]}</script>
+</body></html>"""
+
+
+def _fake(text="", status=200, ctype="text/html; charset=utf-8", final=None, calls=None):
+    def fetch(url, timeout):
+        if calls is not None:
+            calls.append((url, timeout))
+        return text, status, ctype, final or url
+    return fetch
+
+
+def test_registered_without_a_browser():
+    assert web_main.ACTIONS["page-contacts"].needs_driver is False
+
+
+def test_link_in_bio_page(monkeypatch):
+    calls = []
+    monkeypatch.setattr(page, "_fetch", _fake(LINKTREE, calls=calls))
+    r = web_main.dispatch("page-contacts", ["--url", "linktr.ee/jane", "--timeout", "7"])
+    assert calls == [("https://linktr.ee/jane", 7)]
+    assert r["reachable"] is True
+    assert r["title"] == "@jane | Linktree"
+    assert r["emails"] == ["jane@studio.io"]
+    assert r["links"]["linkedin"] == ["https://www.linkedin.com/in/jane-doe"]
+    assert r["links"]["x"] == ["https://x.com/janedoe"]
+    assert r["affiliate_links"][0]["network"] == "partnerstack"
+
+
+def test_error_status_is_unreachable_not_an_error(monkeypatch):
+    monkeypatch.setattr(page, "_fetch", _fake("gone", status=404))
+    r = web_main.dispatch("page-contacts", ["--url", "https://jane.dev"])
+    assert r["reachable"] is False
+    assert r["status"] == 404
+    assert r["emails"] == []
+
+
+def test_plain_text_body(monkeypatch):
+    monkeypatch.setattr(page, "_fetch", _fake("contact: biz@jane.dev", ctype="text/plain"))
+    r = web_main.dispatch("page-contacts", ["--url", "https://jane.dev/contact.txt"])
+    assert r["emails"] == ["biz@jane.dev"]
+
+
+def test_redirect_target_used_as_base_and_own_site_links_dropped(monkeypatch):
+    html = ('<html><body><a href="/about">About</a>'
+            '<a href="https://partner.io/x">Partner</a></body></html>')
+    monkeypatch.setattr(page, "_fetch", _fake(html, final="https://www.jane.dev/home"))
+    r = web_main.dispatch("page-contacts", ["--url", "https://jane.dev"])
+    assert r["final_url"] == "https://www.jane.dev/home"
+    assert r["links"]["website"] == ["https://partner.io/x"]
+
+
+def test_url_required():
+    with pytest.raises(UsageError):
+        web_main.dispatch("page-contacts", [])

procesio_cli/tools/web/tests/test_sessions.py

@@ -0,0 +1,145 @@
+"""Session path resolution, name validation (no traversal), and the
+read/write/list/delete lifecycle - all against an isolated temp dir."""
+from __future__ import annotations
+
+import json
+
+import pytest
+
+from tools.web import sessions
+from tools.web.errors import SessionError, UsageError
+
+
+@pytest.mark.parametrize("bad", [
+    "../escape", "a/b", "a\\b", "", ".hidden", "with space",
+    "x" * 65, "/abs", "..",
+])
+def test_invalid_names_rejected(bad):
+    with pytest.raises(UsageError):
+        sessions.validate_name(bad)
+
+
+@pytest.mark.parametrize("good", ["linkedin", "whats-app", "site_1", "a", "A.B-c_2"])
+def test_valid_names_accepted(good):
+    assert sessions.validate_name(good) == good
+
+
+def test_session_path_is_inside_sessions_dir(isolated_sessions):
+    p = sessions.session_path("linkedin")
+    assert p.parent == isolated_sessions
+    assert p.name == "linkedin.json"
+
+
+def test_write_load_roundtrip(isolated_sessions):
+    state = {"cookies": [{"name": "sid", "value": "v"}], "origins": []}
+    sessions.write_state("acme", state)
+    assert sessions.exists("acme")
+    assert sessions.load_state("acme") == state
+
+
+def test_require_missing_raises_session_error(isolated_sessions):
+    with pytest.raises(SessionError):
+        sessions.require("ghost")
+
+
+def test_load_corrupt_raises_session_error(isolated_sessions):
+    p = sessions.session_path("broken")
+    p.write_text("{ not json", encoding="utf-8")
+    with pytest.raises(SessionError):
+        sessions.load_state("broken")
+
+
+def test_delete_reports_removed_then_missing(isolated_sessions):
+    sessions.write_state("temp", {"cookies": []})
+    out = sessions.delete("temp", confirm=True)
+    assert out["deleted"] is True and out["removed"] == ["state"]
+    again = sessions.delete("temp", confirm=True)
+    assert again["deleted"] is False and again["existed"] is False
+
+
+def _seed_persistent(name):
+    """A persistent session as save-session leaves it: profile dir + sidecar."""
+    sessions.write_state(name, {"cookies": []})
+    prof = sessions.profile_dir(name)
+    (prof / "Default").mkdir(parents=True)
+    (prof / "Default" / "Cookies").write_text("x", encoding="utf-8")
+    sessions.write_cookies(name, [{"name": "sid", "value": "abc"}])
+    return prof
+
+
+def test_delete_removes_profile_and_cookie_sidecar(isolated_sessions):
+    """The live bug: delete only unlinked <name>.json, leaving a stale profile
+    that open_session then silently reused."""
+    prof = _seed_persistent("goog")
+    out = sessions.delete("goog", confirm=True)
+    assert out["deleted"] is True
+    assert sorted(out["removed"]) == ["cookies", "profile", "state"]
+    assert not prof.exists()
+    assert not sessions.cookies_exist("goog")
+    assert not sessions.exists("goog")
+    assert sessions.present_artifacts("goog") == []
+
+
+def test_delete_without_confirm_previews_and_removes_nothing(isolated_sessions):
+    """Deleting a session destroys a login only a human can re-establish, so an
+    unconfirmed call must be a pure preview."""
+    prof = _seed_persistent("goog")
+    out = sessions.delete("goog")
+    assert out["deleted"] is False
+    assert out["confirmation_required"] is True
+    assert sorted(out["would_remove"]) == ["cookies", "profile", "state"]
+    assert out["removed"] == []
+    # nothing touched
+    assert prof.exists() and sessions.cookies_exist("goog") and sessions.exists("goog")
+
+
+def test_delete_missing_session_needs_no_confirmation(isolated_sessions):
+    out = sessions.delete("nope")
+    assert out["existed"] is False and out["deleted"] is False
+    assert "confirmation_required" not in out
+
+
+def test_delete_reports_artifacts_it_could_not_remove(isolated_sessions, monkeypatch):
+    """A locked profile (browser still open) must be reported, not silently
+    counted as deleted."""
+    _seed_persistent("goog")
+
+    def boom(path):
+        raise OSError("profile is in use")
+    monkeypatch.setattr(sessions.shutil, "rmtree", boom)
+
+    out = sessions.delete("goog", confirm=True)
+    assert out["deleted"] is False              # not a success
+    assert "profile" in out["failed"]
+    assert sessions.profile_exists("goog")      # still there
+    assert sorted(out["removed"]) == ["cookies", "state"]
+
+
+def test_list_all_metadata_only(isolated_sessions):
+    sessions.write_state("one", {"cookies": []})
+    sessions.write_state("two", {"cookies": [{"name": "x", "value": "y"}]})
+    items = sessions.list_all()
+    names = [i["name"] for i in items]
+    assert names == ["one", "two"]  # sorted
+    for i in items:
+        assert set(i) == {"name", "bytes", "modified", "persistent"}  # no contents leaked
+        assert i["bytes"] > 0
+        assert i["persistent"] is False
+
+
+def test_list_all_includes_persistent_profiles(isolated_sessions):
+    sessions.write_state("jsonsess", {"cookies": []})
+    prof = sessions.profile_dir("profsess")
+    prof.mkdir()
+    (prof / "Default").write_text("x", encoding="utf-8")  # make it non-empty
+    items = {i["name"]: i for i in sessions.list_all()}
+    assert items["jsonsess"]["persistent"] is False
+    assert items["profsess"]["persistent"] is True
+
+
+def test_list_all_does_not_read_contents(isolated_sessions):
+    # Even a file with secret-looking content only surfaces metadata.
+    secret = {"cookies": [{"name": "auth", "value": "SUPERSECRET"}]}
+    sessions.write_state("s", secret)
+    dumped = json.dumps(sessions.list_all())
+    assert "SUPERSECRET" not in dumped