Skip to content

AI agent skill that researches any topic across Reddit, X, YouTube, HN, Polymarket, and the web - then synthesizes a grounded summary

25.3 KB
Raw Blame
"""Tests for hackernews.py - HN search via Algolia API."""

import json
from datetime import datetime, timezone
from unittest.mock import MagicMock, Mock, patch
from urllib.parse import parse_qs, urlsplit

import pytest

from lib import hackernews

# === Helper Functions ===


def create_mock_hit(
    object_id="12345",
    title="Test HN Story",
    points=100,
    num_comments=50,
    created_at_i=None,
    author="testuser",
    url="https://example.com",
):
    """Create a mock Algolia hit object."""
    if created_at_i is None:
        # Default to 30 days ago
        dt = datetime.now(timezone.utc)
        created_at_i = int(dt.timestamp()) - (30 * 86400)
    
    return {
        "objectID": object_id,
        "title": title,
        "points": points,
        "num_comments": num_comments,
        "created_at_i": created_at_i,
        "author": author,
        "url": url,
    }

# === Tests for _date_to_unix() ===


def test_date_to_unix_basic():
    """Test converting YYYY-MM-DD to Unix timestamp."""
    result = hackernews._date_to_unix("2026-01-01")
    
    # Should be midnight UTC on Jan 1, 2026
    expected = datetime(2026, 1, 1, tzinfo=timezone.utc).timestamp()
    assert result == int(expected)


def test_date_to_unix_leap_day():
    """Test date conversion with leap day."""
    result = hackernews._date_to_unix("2024-02-29")
    
    expected = datetime(2024, 2, 29, tzinfo=timezone.utc).timestamp()
    assert result == int(expected)

# === Tests for _unix_to_date() ===


def test_unix_to_date_basic():
    """Test converting Unix timestamp to YYYY-MM-DD."""
    ts = int(datetime(2026, 1, 15, tzinfo=timezone.utc).timestamp())
    result = hackernews._unix_to_date(ts)
    
    assert result == "2026-01-15"


def test_unix_to_date_with_time():
    """Test that time component is stripped."""
    ts = int(datetime(2026, 1, 15, 14, 30, 45, tzinfo=timezone.utc).timestamp())
    result = hackernews._unix_to_date(ts)
    
    assert result == "2026-01-15"

# === Tests for _strip_html() ===


def test_strip_html_basic():
    """Test HTML stripping and entity decoding."""
    html_text = "<p>Hello &amp; goodbye</p>"
    result = hackernews._strip_html(html_text)
    
    assert result == "Hello & goodbye"


def test_strip_html_paragraph_tags():
    """Test that <p> tags are converted to newlines."""
    html_text = "First<p>Second<p>Third"
    result = hackernews._strip_html(html_text)
    
    assert "First\n" in result
    assert "Second\n" in result


def test_strip_html_nested_tags():
    """Test stripping nested HTML tags."""
    html_text = "<div><a href='test'>Link</a> text <b>bold</b></div>"
    result = hackernews._strip_html(html_text)
    
    assert result == "Link text bold"


def test_strip_html_entities():
    """Test HTML entity decoding and tag stripping."""
    html_text = "Text &amp; &quot;test&quot;"
    result = hackernews._strip_html(html_text)
    
    # Entities are decoded
    assert "&" in result or "test" in result

# === Tests for _title_matches_query() ===


def test_title_matches_query_basic():
    """Test basic query matching."""
    title = "New AI framework for developers"
    query = "AI framework"
    
    assert hackernews._title_matches_query(title, query) is True


def test_title_matches_query_case_insensitive():
    """Test that matching is case-insensitive."""
    title = "NEW AI FRAMEWORK"
    query = "ai framework"
    
    assert hackernews._title_matches_query(title, query) is True


def test_title_matches_query_with_prefix():
    """Test matching with HN prefix stripped."""
    title = "Show HN: My new AI framework"
    query = "AI framework"
    
    # Should match "AI framework" in the content, not the "Show HN:" prefix
    assert hackernews._title_matches_query(title, query) is True


def test_title_matches_query_prefix_only():
    """Test that matching prefix-only returns False."""
    title = "Show HN: Something else entirely"
    query = "Show HN"
    
    # "Show HN" is a prefix, not real content
    # After stripping, "Show HN" won't be in the stripped title
    assert hackernews._title_matches_query(title, query) is False


def test_title_matches_query_empty_query():
    """Test that empty query always matches."""
    title = "Any title"
    query = ""
    
    assert hackernews._title_matches_query(title, query) is True


def test_title_matches_query_partial_match():
    """Any-word matching: at least one query token in title is enough.

    Previously required *all* tokens, which killed every hit on multi-keyword
    theme queries like 'claude, personal agents, agentic infra' since no real
    HN title contains all 5 tokens verbatim. Token-overlap relevance at parse
    time still demotes weak matches, so the loosened gate is safe.
    """
    title = "New AI framework"
    query = "AI blockchain"

    # "AI" matches as a whole word, even though "blockchain" doesn't appear
    assert hackernews._title_matches_query(title, query) is True


def test_title_matches_query_no_token_in_title():
    """If no query token appears in the title at all, reject."""
    assert hackernews._title_matches_query("New rust compiler", "AI blockchain") is False


def test_title_matches_query_word_boundary_not_substring():
    """Short tokens must match on word boundaries, not as substrings.

    Without word-boundary matching, 'ai' would falsely match 'email',
    'rail', 'artists', etc.
    """
    # 'ai' as a substring of 'email' must not match
    assert hackernews._title_matches_query("New email service", "ai blockchain") is False
    # 'ai' as a whole word does match
    assert hackernews._title_matches_query("Cool AI tool launched", "ai blockchain") is True


def test_title_matches_query_flattens_hyphens_and_commas():
    """Query tokens split on hyphens/commas the same way search_hackernews
    flattens them, so the post-filter stays aligned with what Algolia saw."""
    # query 'ts-bun-node' flattens to ['ts', 'bun', 'node']; title contains 'bun'
    assert hackernews._title_matches_query("Bun 1.2 released", "ts-bun-node") is True
    # query 'rust, go, zig' flattens; title contains 'go'
    assert hackernews._title_matches_query("Go 1.24 generics update", "rust, go, zig") is True

# === Tests for search_hackernews() ===

@patch('lib.hackernews.http.request')


def test_search_hackernews_basic(mock_request):
    """Test basic HN search."""
    mock_request.return_value = {
        "hits": [create_mock_hit()],
        "nbHits": 1,
    }
    
    result = hackernews.search_hackernews(
        "AI framework",
        "2026-01-01",
        "2026-01-31",
        depth="quick"
    )
    
    assert "hits" in result
    assert len(result["hits"]) == 1
    assert mock_request.called

@patch('lib.hackernews.http.request')


def test_search_hackernews_depth_config(mock_request):
    """Test that depth parameter controls hit count."""
    mock_request.return_value = {"hits": [], "nbHits": 0}
    
    # Quick mode returns up to 15 hits, but overfetches before client-side
    # engagement filtering so low-point stories do not shrink result depth.
    hackernews.search_hackernews("test", "2026-01-01", "2026-01-31", depth="quick")
    
    call_args = mock_request.call_args[0]
    url = call_args[1]
    
    expected_hits_per_page = (
        hackernews.DEPTH_CONFIG["quick"] * hackernews.HN_OVERFETCH_MULTIPLIER
    )
    assert f"hitsPerPage={expected_hits_per_page}" in url

@patch('lib.hackernews.http.request')


def test_search_hackernews_date_filtering(mock_request):
    """Test that date range is applied correctly."""
    mock_request.return_value = {"hits": [], "nbHits": 0}
    
    hackernews.search_hackernews("test", "2026-01-01", "2026-01-31", depth="quick")
    
    mock_request.assert_called_once()
    url = mock_request.call_args.args[1]
    filters = parse_qs(urlsplit(url).query)["numericFilters"]
    assert filters == ["created_at_i>1767225600,created_at_i<1769904000"]

@patch('lib.hackernews.http.request')


def test_search_hackernews_http_error_handling(mock_request):
    """Test graceful handling of HTTP errors."""
    from lib.http import HTTPError
    mock_request.side_effect = HTTPError("HTTP 429: Too Many Requests")
    
    result = hackernews.search_hackernews("test", "2026-01-01", "2026-01-31")
    
    # Should return empty hits with error
    assert result["hits"] == []
    assert "error" in result

@patch('lib.hackernews.http.request')


def test_search_hackernews_engagement_filter(mock_request):
    """Test that low-engagement stories are filtered client-side."""
    mock_request.return_value = {
        "hits": [
            create_mock_hit(object_id="low", points=2),
            create_mock_hit(object_id="high", points=3),
        ],
        "nbHits": 2,
    }
    
    result = hackernews.search_hackernews("test", "2026-01-01", "2026-01-31")
    
    call_args = mock_request.call_args[0]
    url = call_args[1]
    
    # Algolia rejects points in numericFilters; keep only supported date filters.
    assert "points" not in url
    assert [hit["objectID"] for hit in result["hits"]] == ["high"]


@patch('lib.hackernews.http.request')
def test_search_hackernews_no_points_numericfilter(mock_request):
    """numericFilters must NOT include a `points` clause.

    `points` is not in the HN Algolia index's `numericAttributesForFiltering`,
    so a `points>2` clause returns HTTP 400 ("invalid numeric attribute(points)")
    and zero stories. Engagement is filtered client-side after overfetching
    instead. This guards against the invalid filter being reintroduced.
    """
    mock_request.return_value = {"hits": [], "nbHits": 0}

    hackernews.search_hackernews("test", "2026-01-01", "2026-01-31")

    url = mock_request.call_args[0][1]

    # Date filter stays; the invalid points filter must be gone.
    assert "created_at_i" in url
    assert "points" not in url


@patch('lib.hackernews.http.request')
def test_search_hackernews_truncates_after_overfetch(mock_request):
    """Test that overfetching does not return more than the requested depth."""
    mock_request.return_value = {
        "hits": [
            create_mock_hit(object_id=str(i), points=10)
            for i in range(20)
        ],
        "nbHits": 20,
    }

    result = hackernews.search_hackernews("test", "2026-01-01", "2026-01-31", depth="quick")

    assert len(result["hits"]) == 15
    assert [hit["objectID"] for hit in result["hits"]] == [str(i) for i in range(15)]

# === Tests for parse_hackernews_response() ===


def test_parse_hackernews_response_basic():
    """Test parsing basic Algolia response."""
    response = {
        "hits": [create_mock_hit(
            object_id="123",
            title="Test Story",
            points=100,
            num_comments=50
        )]
    }
    
    items = hackernews.parse_hackernews_response(response)
    
    assert len(items) == 1
    assert items[0]["id"] == "123"
    assert items[0]["title"] == "Test Story"
    assert items[0]["engagement"]["points"] == 100
    assert items[0]["engagement"]["comments"] == 50


def test_parse_hackernews_response_hn_url():
    """Test that HN discussion URL is generated correctly."""
    response = {
        "hits": [create_mock_hit(object_id="12345")]
    }
    
    items = hackernews.parse_hackernews_response(response)
    
    assert items[0]["hn_url"] == "https://news.ycombinator.com/item?id=12345"


def test_parse_hackernews_response_date_conversion():
    """Test that Unix timestamp is converted to YYYY-MM-DD."""
    ts = int(datetime(2026, 1, 15, tzinfo=timezone.utc).timestamp())
    response = {
        "hits": [create_mock_hit(created_at_i=ts)]
    }
    
    items = hackernews.parse_hackernews_response(response)
    
    assert items[0]["date"] == "2026-01-15"


def test_parse_hackernews_response_missing_fields():
    """Test handling of hits with missing optional fields."""
    response = {
        "hits": [{
            "objectID": "123",
            "title": "Test",
            # Missing points, num_comments, created_at_i
        }]
    }
    
    items = hackernews.parse_hackernews_response(response)
    
    assert len(items) == 1
    assert items[0]["engagement"]["points"] == 0
    assert items[0]["engagement"]["comments"] == 0
    assert items[0]["date"] is None


def test_parse_hackernews_response_relevance_scoring():
    """Test that relevance scores are calculated."""
    response = {
        "hits": [
            create_mock_hit(object_id="1", points=100),
            create_mock_hit(object_id="2", points=50),
            create_mock_hit(object_id="3", points=10),
        ]
    }
    
    items = hackernews.parse_hackernews_response(response, query="test")
    
    # Should have relevance scores
    for item in items:
        assert "relevance" in item
        assert 0 <= item["relevance"] <= 1.0
    
    # First item should generally have higher relevance (better rank)
    assert items[0]["relevance"] >= items[2]["relevance"]


def test_parse_hackernews_response_engagement_boost():
    """Test that high-engagement items get relevance boost."""
    high = hackernews.parse_hackernews_response(
        {"hits": [create_mock_hit(object_id="story", points=500, num_comments=5)]},
        query="",
    )[0]
    low = hackernews.parse_hackernews_response(
        {"hits": [create_mock_hit(object_id="story", points=10, num_comments=5)]},
        query="",
    )[0]

    assert high["engagement"]["points"] == 500
    assert low["engagement"]["points"] == 10
    assert high["relevance"] > low["relevance"]


def test_parse_hackernews_response_prefix_filtering():
    """Test that items matching only HN prefixes are filtered."""
    response = {
        "hits": [
            create_mock_hit(title="Show HN: My AI Project", object_id="1"),
            create_mock_hit(title="Show HN: Unrelated Project", object_id="2"),
        ]
    }
    
    # Query for "AI" should keep first, filter second
    items = hackernews.parse_hackernews_response(response, query="AI")
    
    assert len(items) == 1
    assert items[0]["id"] == "1"


def test_parse_hackernews_response_empty_response():
    """Test handling of empty response."""
    response = {"hits": []}
    
    items = hackernews.parse_hackernews_response(response)
    
    assert items == []

# === Tests for engagement scoring ===


def test_engagement_score_calculation():
    """Test that engagement dict contains points and comments."""
    response = {
        "hits": [create_mock_hit(points=150, num_comments=75)]
    }
    
    items = hackernews.parse_hackernews_response(response)
    
    engagement = items[0]["engagement"]
    assert engagement["points"] == 150
    assert engagement["comments"] == 75


def test_engagement_score_zero_values():
    """Test handling of zero engagement values."""
    response = {
        "hits": [{
            "objectID": "123",
            "title": "Test",
            "points": None,
            "num_comments": None,
        }]
    }
    
    items = hackernews.parse_hackernews_response(response)
    
    engagement = items[0]["engagement"]
    assert engagement["points"] == 0
    assert engagement["comments"] == 0


@pytest.mark.parametrize("points", [None, 0])
@patch("lib.hackernews.http.request")
def test_fetch_item_comments_preserves_absent_and_zero_points(mock_request, points):
    """The adapter must distinguish an unmeasured score from a measured zero."""
    mock_request.return_value = {
        "children": [
            {
                "author": "alice",
                "text": "A useful comment.",
                "points": points,
            }
        ]
    }

    result = hackernews._fetch_item_comments("123")

    assert result["comments"][0]["points"] is points


# === Pipeline wiring ===


@patch("lib.hackernews.http.request")
def test_pipeline_hackernews_stream_attaches_top_comments(mock_request):
    """The HN stream must enrich top stories with comments (#1168)."""
    from lib import pipeline, schema

    def fake_request(method, url, **kwargs):
        if url.startswith(hackernews.ALGOLIA_ITEM_URL):
            return {
                "children": [
                    {"author": "alice", "text": "<p>Great launch.</p>", "points": 7},
                ]
            }
        return {
            "hits": [
                create_mock_hit(object_id="1", title="Widget launch", points=300),
                create_mock_hit(object_id="2", title="Widget review", points=50),
            ]
        }

    mock_request.side_effect = fake_request
    subquery = schema.SubQuery(
        label="primary",
        search_query="widget",
        ranking_query="widget",
        sources=["hackernews"],
    )

    items, _ = pipeline._retrieve_stream_impl(
        topic="widget",
        subquery=subquery,
        source="hackernews",
        config={},
        depth="quick",
        date_range=("2026-08-24", "2026-09-23"),
        runtime=schema.ProviderRuntime(
            reasoning_provider="none",
            planner_model="none",
            rerank_model="none",
        ),
        mock=False,
    )

    by_id = {item["id"]: item for item in items}
    assert by_id["1"]["top_comments"] == [
        {
            "author": "alice",
            "text": "Great launch.",
            "points": 7,
            # No Algolia child id, so the link is the story's discussion page.
            "url": "https://news.ycombinator.com/item?id=1",
        }
    ]
    assert by_id["1"]["comment_insights"] == ["Great launch."]
    item_urls = [
        call.args[1] for call in mock_request.call_args_list
        if call.args[1].startswith(hackernews.ALGOLIA_ITEM_URL)
    ]
    assert sorted(item_urls) == [
        f"{hackernews.ALGOLIA_ITEM_URL}/1",
        f"{hackernews.ALGOLIA_ITEM_URL}/2",
    ]


@patch("lib.http.time.sleep")
@patch("lib.http.urllib.request.urlopen")
@patch("lib.hackernews.search_hackernews")
def test_pipeline_hackernews_reports_failed_comment_enrichment(
    mock_search, mock_urlopen, _mock_sleep
):
    """Rate-limited item fetches keep the stories but surface in the outcome."""
    import urllib.error

    from lib import pipeline, schema

    mock_search.return_value = {
        "hits": [
            create_mock_hit(object_id="1", title="Widget launch", points=300),
            create_mock_hit(object_id="2", title="Widget review", points=50),
        ]
    }
    mock_urlopen.side_effect = urllib.error.HTTPError(
        hackernews.ALGOLIA_ITEM_URL, 429, "Too Many Requests", {}, None
    )
    subquery = schema.SubQuery(
        label="primary",
        search_query="widget",
        ranking_query="widget",
        sources=["hackernews"],
    )

    items, artifact = pipeline._retrieve_stream(
        topic="widget",
        subquery=subquery,
        source="hackernews",
        config={},
        depth="quick",
        date_range=("2026-08-24", "2026-09-23"),
        runtime=schema.ProviderRuntime(
            reasoning_provider="none",
            planner_model="none",
            rerank_model="none",
        ),
        mock=False,
    )

    assert sorted(item["id"] for item in items) == ["1", "2"]
    assert all(item["top_comments"] == [] for item in items)
    assert "_source_outcome" not in artifact
    assert "2 sub-requests rate-limited (HTTP 429)" in artifact["_source_outcome_detail"]
    assert artifact["_source_outcome_detail_state"] == schema.RATE_LIMITED


# === HN kids ordering (#1285) ===


@patch("lib.hackernews.http.request")
def test_fetch_item_comments_orders_by_firebase_kids(mock_request):
    """Quoted comments follow HN thread order, not Algolia child / id order."""

    def fake_request(method, url, **kwargs):
        if url.startswith(hackernews.FIREBASE_ITEM_URL):
            # HN ranks B then A then C; Algolia listed them A, B, C (id order).
            return {"kids": [2, 1, 3]}
        if url.startswith(hackernews.ALGOLIA_ITEM_URL):
            return {
                "children": [
                    {"id": 1, "author": "alice", "text": "<p>First posted.</p>", "points": None},
                    {"id": 2, "author": "bob", "text": "<p>Top-ranked reply.</p>", "points": None},
                    {"id": 3, "author": "carol", "text": "<p>Third.</p>", "points": None},
                ]
            }
        raise AssertionError(f"unexpected url: {url}")

    mock_request.side_effect = fake_request
    result = hackernews._fetch_item_comments("50019911", max_comments=2)

    assert [c["author"] for c in result["comments"]] == ["bob", "alice"]
    assert result["comments"][0]["url"] == "https://news.ycombinator.com/item?id=2"


@patch("lib.hackernews.http.request")
def test_fetch_item_comments_falls_back_to_points_when_kids_unavailable(mock_request):
    """If the Firebase kids fetch fails, keep the previous points ordering."""

    def fake_request(method, url, **kwargs):
        if url.startswith(hackernews.FIREBASE_ITEM_URL):
            raise hackernews.http.HTTPError("firebase down", status_code=503)
        return {
            "children": [
                {"id": 1, "author": "alice", "text": "low", "points": 1},
                {"id": 2, "author": "bob", "text": "high", "points": 9},
            ]
        }

    mock_request.side_effect = fake_request
    result = hackernews._fetch_item_comments("123", max_comments=2)
    assert [c["author"] for c in result["comments"]] == ["bob", "alice"]


def test_order_comments_by_kids_appends_unknowns():
    comments = [
        {"id": 1, "author": "a"},
        {"id": 2, "author": "b"},
        {"id": 99, "author": "extra"},
    ]
    ordered = hackernews._order_comments_by_kids(comments, [2, 1])
    assert [c["id"] for c in ordered] == [2, 1, 99]


@patch("lib.http.time.sleep")
@patch("lib.http.urllib.request.urlopen")
def test_firebase_kids_failure_stays_out_of_failure_sink(mock_urlopen, _mock_sleep):
    """A Firebase outage keeps the Algolia comments and records no run failure."""
    import urllib.error

    from lib import http as lib_http

    algolia_body = json.dumps({
        "children": [
            {"id": 1, "author": "alice", "text": "low", "points": 1},
            {"id": 2, "author": "bob", "text": "high", "points": 9},
        ]
    }).encode("utf-8")
    firebase_calls = []

    def fake_urlopen(req, timeout=None):
        url = req.full_url
        if url.startswith(hackernews.FIREBASE_ITEM_URL):
            firebase_calls.append(url)
            raise urllib.error.HTTPError(url, 503, "Service Unavailable", {}, None)
        response = MagicMock()
        response.__enter__.return_value = response
        response.__exit__.return_value = False
        response.read.return_value = algolia_body
        response.status = 200
        return response

    mock_urlopen.side_effect = fake_urlopen
    with lib_http.capture_failures() as failures:
        result = hackernews._fetch_item_comments("123", max_comments=2)

    assert firebase_calls
    assert failures == []
    assert [c["author"] for c in result["comments"]] == ["bob", "alice"]



@pytest.mark.parametrize("firebase_read", ["incomplete", "non_utf8"])
@patch("lib.http.time.sleep")
@patch("lib.http.urllib.request.urlopen")
def test_firebase_kids_unwrapped_read_errors_fall_back(mock_urlopen, _mock_sleep, firebase_read):
    """A truncated or undecodable Firebase body keeps the Algolia comments."""
    import http.client

    from lib import http as lib_http

    algolia_body = json.dumps({
        "children": [
            {"id": 1, "author": "alice", "text": "low", "points": 1},
            {"id": 2, "author": "bob", "text": "high", "points": 9},
        ]
    }).encode("utf-8")

    def fake_urlopen(req, timeout=None):
        response = MagicMock()
        response.__enter__.return_value = response
        response.__exit__.return_value = False
        response.status = 200
        if req.full_url.startswith(hackernews.FIREBASE_ITEM_URL):
            if firebase_read == "incomplete":
                response.read.side_effect = http.client.IncompleteRead(b'{"kids": [1')
            else:
                response.read.return_value = b"\xff\xfe"
        else:
            response.read.return_value = algolia_body
        return response

    mock_urlopen.side_effect = fake_urlopen
    with lib_http.capture_failures() as failures:
        result = hackernews._fetch_item_comments("123", max_comments=2)

    assert failures == []
    assert [c["author"] for c in result["comments"]] == ["bob", "alice"]



@patch("lib.http.time.sleep")
@patch("lib.http.urllib.request.urlopen")
def test_firebase_kids_timeouts_are_bounded(mock_urlopen, _mock_sleep):
    """A hanging Firebase gets a short retry budget, not the default five attempts."""
    from lib import http as lib_http

    algolia_body = json.dumps({
        "children": [
            {"id": 1, "author": "alice", "text": "low", "points": 1},
            {"id": 2, "author": "bob", "text": "high", "points": 9},
        ]
    }).encode("utf-8")
    firebase_timeouts = []

    def fake_urlopen(req, timeout=None):
        if req.full_url.startswith(hackernews.FIREBASE_ITEM_URL):
            firebase_timeouts.append(timeout)
            raise TimeoutError("timed out")
        response = MagicMock()
        response.__enter__.return_value = response
        response.__exit__.return_value = False
        response.status = 200
        response.read.return_value = algolia_body
        return response

    mock_urlopen.side_effect = fake_urlopen
    with lib_http.capture_failures() as failures:
        result = hackernews._fetch_item_comments("123", max_comments=2)

    assert 1 <= len(firebase_timeouts) <= hackernews.FIREBASE_KIDS_RETRIES
    assert all(t <= hackernews.FIREBASE_KIDS_TIMEOUT for t in firebase_timeouts)
    assert failures == []
    assert [c["author"] for c in result["comments"]] == ["bob", "alice"]


if __name__ == "__main__":
    pytest.main([__file__, "-v"])