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

cli_web/hackernews/tests/test_core.py

@@ -0,0 +1,365 @@
+"""Unit tests for cli-web-hackernews core modules (mocked HTTP, no network)."""
+
+from __future__ import annotations
+
+from unittest.mock import MagicMock, patch
+
+import httpx
+import pytest
+from cli_web.hackernews.core.client import HackerNewsClient
+from cli_web.hackernews.core.exceptions import (
+    AppError,
+    AuthError,
+    NetworkError,
+    NotFoundError,
+    RateLimitError,
+    ServerError,
+)
+from cli_web.hackernews.core.models import Comment, SearchResult, Story, User
+
+# ─── Model tests ─────────────────────────────────────────────────────────────
+
+
+class TestStoryModel:
+    def test_to_dict_includes_computed(self):
+        story = Story(
+            id=123,
+            title="Test Story",
+            url="https://example.com/article",
+            score=42,
+            by="testuser",
+            time=0,
+            descendants=5,
+        )
+        d = story.to_dict()
+        assert d["id"] == 123
+        assert d["title"] == "Test Story"
+        assert d["domain"] == "example.com"
+        assert "age" in d
+
+    def test_domain_extraction(self):
+        story = Story(id=1, title="T", url="https://www.example.com/path")
+        assert story.domain == "example.com"
+
+    def test_domain_empty_when_no_url(self):
+        story = Story(id=1, title="T")
+        assert story.domain == ""
+
+    def test_age_empty_when_no_time(self):
+        story = Story(id=1, title="T")
+        assert story.age == ""
+
+
+class TestCommentModel:
+    def test_text_plain_strips_html(self):
+        comment = Comment(id=1, text="<p>Hello <b>world</b></p>")
+        assert comment.text_plain == "Hello world"
+
+    def test_text_plain_unescapes_entities(self):
+        comment = Comment(id=1, text="&amp; &lt;tag&gt;")
+        assert comment.text_plain == "& <tag>"
+
+    def test_text_plain_empty(self):
+        comment = Comment(id=1)
+        assert comment.text_plain == ""
+
+
+class TestUserModel:
+    def test_to_dict_trims_submitted(self):
+        user = User(id="test", submitted=list(range(100)))
+        d = user.to_dict()
+        assert len(d["submitted"]) == 20
+        assert d["total_submissions"] == 100
+
+    def test_about_plain(self):
+        user = User(id="test", about="<p>Hello &amp; welcome</p>")
+        assert user.about_plain == "Hello & welcome"
+
+
+class TestSearchResultModel:
+    def test_to_dict(self):
+        result = SearchResult(
+            objectID="123",
+            title="Test",
+            author="user",
+            points=42,
+            num_comments=10,
+        )
+        d = result.to_dict()
+        assert d["objectID"] == "123"
+        assert d["points"] == 42
+
+
+# ─── Client HTTP error handling tests ───────────────────────────────────────
+
+
+class TestClientHTTPErrors:
+    def _mock_response(self, status_code: int, headers: dict | None = None, json_data=None):
+        resp = MagicMock()
+        resp.status_code = status_code
+        resp.headers = headers or {}
+        resp.json.return_value = json_data
+        return resp
+
+    def test_rate_limit_raises(self):
+        client = HackerNewsClient()
+        client._client = MagicMock()
+        client._client.get.return_value = self._mock_response(429, headers={"retry-after": "30"})
+        with pytest.raises(RateLimitError) as exc_info:
+            client._get_json("https://hacker-news.firebaseio.com/v0/topstories.json")
+        assert exc_info.value.retry_after == 30
+
+    def test_server_error_raises(self):
+        client = HackerNewsClient()
+        client._client = MagicMock()
+        client._client.get.return_value = self._mock_response(503)
+        with pytest.raises(ServerError):
+            client._get_json("https://hacker-news.firebaseio.com/v0/topstories.json")
+
+    def test_404_raises_not_found(self):
+        client = HackerNewsClient()
+        client._client = MagicMock()
+        client._client.get.return_value = self._mock_response(404)
+        with pytest.raises(NotFoundError):
+            client._get_json("https://hacker-news.firebaseio.com/v0/item/999999999.json")
+
+    def test_network_error_raises(self):
+        client = HackerNewsClient()
+        client._client = MagicMock()
+        client._client.get.side_effect = httpx.ConnectError("Connection refused")
+        with pytest.raises(NetworkError):
+            client._get_json("https://hacker-news.firebaseio.com/v0/topstories.json")
+
+    def test_timeout_raises_network_error(self):
+        client = HackerNewsClient()
+        client._client = MagicMock()
+        client._client.get.side_effect = httpx.TimeoutException("Timed out")
+        with pytest.raises(NetworkError):
+            client._get_json("https://hacker-news.firebaseio.com/v0/topstories.json")
+
+
+# ─── Client data parsing tests ──────────────────────────────────────────────
+
+
+class TestClientParsing:
+    def test_get_story_builds_model(self):
+        mock_data = {
+            "id": 123,
+            "title": "Test Story",
+            "url": "https://example.com",
+            "score": 42,
+            "by": "user",
+            "time": 1700000000,
+            "descendants": 5,
+            "type": "story",
+        }
+        with patch.object(HackerNewsClient, "get_item", return_value=mock_data):
+            client = HackerNewsClient()
+            story = client.get_story(123)
+            assert isinstance(story, Story)
+            assert story.id == 123
+            assert story.title == "Test Story"
+            assert story.score == 42
+
+    def test_get_user_builds_model(self):
+        mock_data = {
+            "id": "testuser",
+            "karma": 1000,
+            "created": 1187454947,
+            "about": "Hi",
+            "submitted": [1, 2, 3],
+        }
+        with patch.object(HackerNewsClient, "_get_json", return_value=mock_data):
+            client = HackerNewsClient()
+            user = client.get_user("testuser")
+            assert isinstance(user, User)
+            assert user.id == "testuser"
+            assert user.karma == 1000
+
+    def test_get_user_not_found(self):
+        with patch.object(HackerNewsClient, "_get_json", return_value=None):
+            client = HackerNewsClient()
+            with pytest.raises(NotFoundError):
+                client.get_user("nonexistent")
+
+    def test_search_builds_results(self):
+        mock_data = {
+            "hits": [
+                {
+                    "objectID": "123",
+                    "title": "Result 1",
+                    "url": "https://example.com",
+                    "author": "user",
+                    "points": 42,
+                    "num_comments": 10,
+                    "created_at": "2024-01-01T00:00:00Z",
+                },
+            ]
+        }
+        with patch.object(HackerNewsClient, "_get_json", return_value=mock_data):
+            client = HackerNewsClient()
+            results = client.search("test")
+            assert len(results) == 1
+            assert results[0].objectID == "123"
+            assert results[0].points == 42
+
+
+# ─── Exception serialization tests ──────────────────────────────────────────
+
+
+class TestExceptionsToDicts:
+    def test_app_error_to_dict(self):
+        exc = AppError("something broke", "TEST_ERROR")
+        d = exc.to_dict()
+        assert d["error"] is True
+        assert d["code"] == "TEST_ERROR"
+        assert "something broke" in d["message"]
+
+    def test_rate_limit_error_to_dict(self):
+        exc = RateLimitError(60)
+        d = exc.to_dict()
+        assert d["code"] == "RATE_LIMITED"
+        assert d["retry_after"] == 60
+
+    def test_server_error_to_dict(self):
+        exc = ServerError(503)
+        d = exc.to_dict()
+        assert d["code"] == "SERVER_ERROR"
+        assert "503" in d["message"]
+
+    def test_not_found_to_dict(self):
+        exc = NotFoundError("Item 123")
+        d = exc.to_dict()
+        assert d["code"] == "NOT_FOUND"
+        assert "Item 123" in d["message"]
+
+    def test_auth_error_to_dict(self):
+        exc = AuthError()
+        d = exc.to_dict()
+        assert d["error"] is True
+        assert d["code"] == "AUTH_EXPIRED"
+        assert "login" in d["message"].lower()
+
+    def test_auth_error_recoverable(self):
+        exc = AuthError("token expired", recoverable=True)
+        assert exc.recoverable is True
+
+
+# ─── Auth module tests ───────────────────────────────────────────────────────
+
+
+class TestAuthModule:
+    def test_require_auth_raises_without_cookie(self):
+        client = HackerNewsClient()
+        with pytest.raises(AuthError):
+            client._require_auth()
+
+    def test_require_auth_returns_cookie(self):
+        client = HackerNewsClient(user_cookie="test_cookie")
+        assert client._require_auth() == "test_cookie"
+
+    def test_extract_auth_token_from_html(self):
+        html = '<a id="up_12345" href="vote?id=12345&amp;how=up&amp;auth=abc123def456"></a>'
+        client = HackerNewsClient(user_cookie="test")
+        token = client._extract_auth_token(html, 12345)
+        assert token == "abc123def456"
+
+    def test_extract_auth_token_missing_raises(self):
+        html = "<html><body>No tokens here</body></html>"
+        client = HackerNewsClient(user_cookie="test")
+        with pytest.raises(AuthError):
+            client._extract_auth_token(html, 99999)
+
+    def test_parse_stories_from_html_extracts_ids(self):
+        html = """
+        <tr class="athing submission" id="12345"><td></td></tr>
+        <tr class="athing submission" id="67890"><td></td></tr>
+        """
+        client = HackerNewsClient(user_cookie="test")
+        # Mock _fetch_items_parallel to return stories based on IDs
+        with patch.object(
+            client,
+            "_fetch_items_parallel",
+            return_value=[
+                Story(id=12345, title="Story 1"),
+                Story(id=67890, title="Story 2"),
+            ],
+        ):
+            stories = client._parse_stories_from_html(html)
+            assert len(stories) == 2
+
+    def test_authenticated_get_html_403_raises_auth_error(self):
+        client = HackerNewsClient(user_cookie="expired_cookie")
+        resp = MagicMock()
+        resp.status_code = 403
+        client._web_client = MagicMock()
+        client._web_client.request.return_value = resp
+        with (
+            patch(
+                "cli_web.hackernews.core.client.load_auth",
+                side_effect=AuthError("not logged in"),
+            ),
+            patch(
+                "cli_web.hackernews.core.client.refresh_auth",
+                side_effect=AuthError("session expired"),
+            ),
+        ):
+            with pytest.raises(AuthError):
+                client._get_html("https://news.ycombinator.com/item?id=1")
+
+
+# ─── Auth retry tests (3-attempt contract, CONVENTIONS.md §Auth Rules) ───────
+
+
+class TestAuthRetry:
+    """401/403 → reload auth.json → headless refresh_auth() → AuthError. Never >3."""
+
+    def _response(self, status_code: int) -> MagicMock:
+        resp = MagicMock()
+        resp.status_code = status_code
+        resp.text = "<html></html>"
+        return resp
+
+    def test_three_attempts_then_auth_error(self):
+        client = HackerNewsClient(user_cookie="alice&stale")
+        client._web_client = MagicMock()
+        client._web_client.request.return_value = self._response(403)
+
+        with (
+            patch(
+                "cli_web.hackernews.core.client.load_auth",
+                return_value={"user_cookie": "alice&disk", "username": "alice"},
+            ) as mock_load,
+            patch(
+                "cli_web.hackernews.core.client.refresh_auth",
+                return_value={"user_cookie": "alice&fresh", "username": "alice"},
+            ) as mock_refresh,
+        ):
+            with pytest.raises(AuthError):
+                client._web_request("GET", "https://news.ycombinator.com/submit")
+
+        assert client._web_client.request.call_count == 3
+        assert mock_load.call_count == 1
+        assert mock_refresh.call_count == 1
+
+    def test_success_after_disk_reload_stops_retrying(self):
+        client = HackerNewsClient(user_cookie="alice&stale")
+        client._web_client = MagicMock()
+        client._web_client.request.side_effect = [
+            self._response(403),
+            self._response(200),
+        ]
+
+        with (
+            patch(
+                "cli_web.hackernews.core.client.load_auth",
+                return_value={"user_cookie": "alice&disk", "username": "alice"},
+            ),
+            patch("cli_web.hackernews.core.client.refresh_auth") as mock_refresh,
+        ):
+            response = client._web_request("GET", "https://news.ycombinator.com/submit")
+
+        assert response.status_code == 200
+        assert client._web_client.request.call_count == 2
+        mock_refresh.assert_not_called()
+        assert client._user_cookie == "alice&disk"

cli_web/hackernews/tests/test_e2e.py

@@ -0,0 +1,267 @@
+"""E2E tests for cli-web-hackernews (live API, no mocks) + subprocess tests."""
+
+from __future__ import annotations
+
+import json
+import os
+import shutil
+import subprocess
+import sys
+
+import pytest
+from cli_web.hackernews.core import auth
+from cli_web.hackernews.core.client import HackerNewsClient
+from cli_web.hackernews.core.exceptions import NotFoundError
+from cli_web.hackernews.core.models import Comment, SearchResult, Story, User
+
+# ─── Fixtures ─────────────────────────────────────────────────────────────────
+
+
+@pytest.fixture
+def client():
+    return HackerNewsClient()
+
+
+def _resolve_cli(name: str) -> str:
+    """Find the CLI binary path for subprocess tests."""
+    if os.environ.get("CLI_WEB_FORCE_INSTALLED"):
+        path = shutil.which(name)
+        if path:
+            return path
+        raise FileNotFoundError(f"{name} not found in PATH")
+    path = shutil.which(name)
+    if path:
+        return path
+    return f"{sys.executable} -m cli_web.hackernews"
+
+
+# ─── E2E: Stories Feed Tests ─────────────────────────────────────────────────
+
+
+class TestStoriesFeedE2E:
+    def test_top_stories_returns_list(self, client):
+        stories = client.get_stories("top", limit=5)
+        assert len(stories) >= 1
+        assert all(isinstance(s, Story) for s in stories)
+
+    def test_new_stories_returns_list(self, client):
+        stories = client.get_stories("new", limit=5)
+        assert len(stories) >= 1
+
+    def test_best_stories_returns_list(self, client):
+        stories = client.get_stories("best", limit=5)
+        assert len(stories) >= 1
+
+    def test_ask_stories_returns_list(self, client):
+        stories = client.get_stories("ask", limit=5)
+        assert len(stories) >= 1
+
+    def test_show_stories_returns_list(self, client):
+        stories = client.get_stories("show", limit=5)
+        assert len(stories) >= 1
+
+    def test_job_stories_returns_list(self, client):
+        stories = client.get_stories("job", limit=5)
+        assert len(stories) >= 1
+
+    def test_story_has_required_fields(self, client):
+        stories = client.get_stories("top", limit=1)
+        story = stories[0]
+        assert story.id > 0
+        assert story.title
+        assert story.by
+        assert story.score >= 0
+
+    def test_story_ids_returns_ints(self, client):
+        ids = client.get_story_ids("top")
+        assert len(ids) > 0
+        assert all(isinstance(i, int) for i in ids[:10])
+
+
+# ─── E2E: Story View + Comments ──────────────────────────────────────────────
+
+
+class TestStoryViewE2E:
+    def test_get_story_by_id(self, client):
+        # Get a real story ID from top stories
+        ids = client.get_story_ids("top")
+        story = client.get_story(ids[0])
+        assert isinstance(story, Story)
+        assert story.id == ids[0]
+        assert story.title
+
+    def test_get_comments_for_story(self, client):
+        # Find a story with comments
+        stories = client.get_stories("top", limit=5)
+        story_with_comments = None
+        for s in stories:
+            if s.descendants > 0:
+                story_with_comments = s
+                break
+        if story_with_comments is None:
+            pytest.skip("No stories with comments found")
+        comments = client.get_comments(story_with_comments.id, limit=3)
+        assert len(comments) >= 1
+        assert all(isinstance(c, Comment) for c in comments)
+        assert comments[0].by  # Has author
+
+
+# ─── E2E: User Profile ──────────────────────────────────────────────────────
+
+
+class TestUserE2E:
+    def test_get_user_profile(self, client):
+        user = client.get_user("dang")
+        assert isinstance(user, User)
+        assert user.id == "dang"
+        assert user.karma > 0
+        assert user.created > 0
+
+    def test_get_nonexistent_user_raises(self, client):
+        with pytest.raises(NotFoundError):
+            client.get_user("thisisanonexistentuser999999")
+
+
+# ─── E2E: Search ────────────────────────────────────────────────────────────
+
+
+class TestSearchE2E:
+    def test_search_stories(self, client):
+        results = client.search("python", tags="story", hits_per_page=5)
+        assert len(results) >= 1
+        assert all(isinstance(r, SearchResult) for r in results)
+        assert results[0].title
+
+    def test_search_by_date(self, client):
+        results = client.search("javascript", sort_by_date=True, hits_per_page=3)
+        assert len(results) >= 1
+
+    def test_search_comments(self, client):
+        results = client.search("react", tags="comment", hits_per_page=3)
+        assert len(results) >= 1
+
+
+# ─── Subprocess Tests ───────────────────────────────────────────────────────
+
+
+class TestSubprocess:
+    def _run(self, args: str, timeout: int = 30) -> subprocess.CompletedProcess:
+        cli_path = _resolve_cli("cli-web-hackernews")
+        cmd = f"{cli_path} {args}"
+        return subprocess.run(
+            cmd,
+            shell=True,
+            capture_output=True,
+            text=True,
+            timeout=timeout,
+        )
+
+    def test_version(self):
+        result = self._run("--version")
+        assert result.returncode == 0
+        assert "0.2.0" in result.stdout
+
+    def test_help(self):
+        result = self._run("--help")
+        assert result.returncode == 0
+        assert "hackernews" in result.stdout.lower()
+
+    def test_stories_top_json(self):
+        result = self._run("stories top -n 3 --json")
+        assert result.returncode == 0
+        data = json.loads(result.stdout)
+        assert isinstance(data, list)
+        assert len(data) >= 1
+        assert "title" in data[0]
+        assert "score" in data[0]
+
+    def test_search_stories_json(self):
+        result = self._run('search stories "python" -n 3 --json')
+        assert result.returncode == 0
+        data = json.loads(result.stdout)
+        assert isinstance(data, list)
+        assert len(data) >= 1
+
+    def test_user_view_json(self):
+        result = self._run("user view dang --json")
+        assert result.returncode == 0
+        data = json.loads(result.stdout)
+        assert data["id"] == "dang"
+        assert data["karma"] > 0
+
+    def test_stories_view_json(self):
+        # Get a story ID first
+        result = self._run("stories top -n 1 --json")
+        assert result.returncode == 0
+        stories = json.loads(result.stdout)
+        story_id = stories[0]["id"]
+
+        result = self._run(f"stories view {story_id} --no-comments --json")
+        assert result.returncode == 0
+        data = json.loads(result.stdout)
+        assert data["id"] == story_id
+
+    def test_auth_status_json(self):
+        result = self._run("auth status --json")
+        assert result.returncode == 0
+        data = json.loads(result.stdout)
+        assert "logged_in" in data
+
+    def test_auth_help(self):
+        result = self._run("auth --help")
+        assert result.returncode == 0
+        assert "login" in result.stdout.lower()
+
+    def test_upvote_help(self):
+        result = self._run("upvote --help")
+        assert result.returncode == 0
+        assert "item_id" in result.stdout.lower()
+
+    def test_submit_help(self):
+        result = self._run("submit --help")
+        assert result.returncode == 0
+        assert "title" in result.stdout.lower()
+
+    def test_comment_help(self):
+        result = self._run("comment --help")
+        assert result.returncode == 0
+        assert "parent_id" in result.stdout.lower()
+
+
+# ─── E2E: Auth-Enabled Tests (require auth cookie) ─────────────────────────
+
+
+@pytest.fixture
+def auth_client():
+    """Create an authenticated client. Fails if not logged in."""
+    cookie = auth.get_user_cookie()
+    return HackerNewsClient(user_cookie=cookie)
+
+
+class TestAuthActionsE2E:
+    def test_upvote_story(self, auth_client):
+        """Test upvoting a top story."""
+        # Get a real story to upvote
+        ids = auth_client.get_story_ids("top")
+        result = auth_client.upvote(ids[0])
+        assert result["success"] is True
+        assert result["action"] == "upvoted"
+
+    def test_get_submissions(self, auth_client):
+        """Test fetching dang's submissions (well-known user)."""
+        stories = auth_client.get_submissions("dang", limit=3)
+        assert len(stories) >= 1
+        assert all(isinstance(s, Story) for s in stories)
+
+    def test_favorite_and_list(self, auth_client):
+        """Test favoriting a story."""
+        ids = auth_client.get_story_ids("top")
+        result = auth_client.favorite(ids[0])
+        assert result["success"] is True
+        assert result["action"] == "favorited"
+
+    def test_auth_validate(self):
+        """Test auth validation works."""
+        result = auth.validate_auth()
+        assert result["valid"] is True
+        assert result["username"]