test_poll_http.py

"""Direct unit tests for `poll.http` (roadmap M4, ADR-0025, extended ADR-0031).

`tests/test_poll_adapters.py` already covers `get_json`/`strip_html`'s original ADR-0025
behavior end to end via the greenhouse/lever adapters. This file covers the primitives ADR-0031
added (`post_json`, `get_text`, retries, `HttpError`, `BlockedUrlError`, `is_public_http_url`)
directly, at the module's own boundary (mocking `urlopen`), rather than only incidentally through
whichever adapter happens to call them.
"""
from __future__ import annotations

import email.message
import json
from unittest.mock import MagicMock, patch
from urllib.error import HTTPError, URLError

import pytest

from openjobradar.poll.http import (
    BlockedUrlError,
    HttpError,
    UnsupportedUrlError,
    get_json,
    get_text,
    is_public_http_url,
    post_json,
    strip_html,
)


def _response(status: int, body: bytes) -> MagicMock:
    resp = MagicMock()
    resp.status = status
    resp.read.return_value = body
    resp.__enter__.return_value = resp
    resp.__exit__.return_value = False
    return resp


class TestGetJson:
    def test_rejects_non_https_urls(self) -> None:
        with pytest.raises(UnsupportedUrlError):
            get_json("http://example.com/insecure")
        with pytest.raises(UnsupportedUrlError):
            get_json("file:///etc/passwd")

    def test_parses_successful_response(self) -> None:
        with patch("openjobradar.poll.http.urlopen", return_value=_response(200, b'{"a": 1}')):
            assert get_json("https://example.com/api") == {"a": 1}

    def test_raises_http_error_on_4xx(self) -> None:
        with (
            patch("openjobradar.poll.http.urlopen", return_value=_response(404, b"{}")),
            pytest.raises(HttpError) as exc_info,
        ):
            get_json("https://example.com/api")
        assert exc_info.value.status == 404

    def test_http_error_response_is_parsed_not_raised_by_urlopen(self) -> None:
        # urlopen itself raises HTTPError for a 4xx/5xx; get_json must still surface it as our
        # own HttpError with the real status, not let the raw HTTPError escape.
        err = HTTPError(
            "https://example.com/api", 500, "boom", email.message.Message(), MagicMock(read=lambda: b"{}")
        )
        with patch("openjobradar.poll.http.urlopen", side_effect=err), pytest.raises(HttpError) as exc_info:
            get_json("https://example.com/api")
        assert exc_info.value.status == 500


class TestPostJson:
    def test_rejects_non_https_urls(self) -> None:
        with pytest.raises(UnsupportedUrlError):
            post_json("http://example.com/api", {})

    def test_posts_body_and_parses_response(self) -> None:
        with patch("openjobradar.poll.http.urlopen", return_value=_response(200, b'{"ok": true}')) as mock_open:
            result = post_json("https://example.com/api", {"q": "engineer"})
        assert result == {"ok": True}
        request = mock_open.call_args[0][0]
        assert request.method == "POST"
        assert json.loads(request.data) == {"q": "engineer"}

    def test_raises_http_error_on_failure_status(self) -> None:
        with (
            patch("openjobradar.poll.http.urlopen", return_value=_response(403, b"{}")),
            pytest.raises(HttpError),
        ):
            post_json("https://example.com/api", {})


class TestGetText:
    def test_returns_status_and_body_without_raising(self) -> None:
        with patch("openjobradar.poll.http.urlopen", return_value=_response(200, b"hello")):
            status, body = get_text("https://example.com/page")
        assert status == 200
        assert body == "hello"

    def test_returns_error_status_rather_than_raising(self) -> None:
        with patch("openjobradar.poll.http.urlopen", return_value=_response(404, b"not found")):
            status, body = get_text("https://example.com/missing")
        assert status == 404
        assert body == "not found"

    def test_rejects_non_https_urls(self) -> None:
        with pytest.raises(UnsupportedUrlError):
            get_text("http://example.com/page")


class TestRetries:
    def test_retries_transient_transport_errors_then_succeeds(self) -> None:
        calls = [URLError("connection reset"), _response(200, b'{"a": 1}')]

        def fake_urlopen(request: object, timeout: int) -> object:
            result = calls.pop(0)
            if isinstance(result, Exception):
                raise result
            return result

        with patch("openjobradar.poll.http.urlopen", side_effect=fake_urlopen), patch(
            "openjobradar.poll.http.time.sleep"
        ):
            assert get_json("https://example.com/api", retries=1) == {"a": 1}

    def test_exhausts_retries_and_raises(self) -> None:
        with patch("openjobradar.poll.http.urlopen", side_effect=URLError("down")), patch(
            "openjobradar.poll.http.time.sleep"
        ), pytest.raises(URLError):
            get_json("https://example.com/api", retries=2)


class TestStripHtml:
    def test_removes_tags_and_collapses_whitespace(self) -> None:
        assert strip_html("<p>Hello   <b>world</b></p>\n<p>!</p>") == "Hello world !"

    def test_of_empty_string_is_empty(self) -> None:
        assert strip_html("") == ""

    def test_handles_double_encoded_entities(self) -> None:
        assert strip_html("&lt;p&gt;Hi&lt;/p&gt;") == "Hi"


class TestIsPublicHttpUrl:
    def test_rejects_non_https_scheme(self) -> None:
        assert is_public_http_url("http://example.com") is False
        assert is_public_http_url("ftp://example.com") is False

    def test_rejects_url_with_embedded_credentials(self) -> None:
        assert is_public_http_url("https://user:pass@example.com") is False

    def test_rejects_malformed_url(self) -> None:
        assert is_public_http_url("https://[::not-valid") is False

    def test_rejects_private_and_link_local_hosts(self) -> None:
        with patch("openjobradar.poll.http.socket.getaddrinfo") as mock_dns:
            mock_dns.return_value = [(None, None, None, None, ("169.254.169.254", 0))]
            assert is_public_http_url("https://metadata.internal/") is False

    def test_accepts_a_resolvable_public_host(self) -> None:
        with patch("openjobradar.poll.http.socket.getaddrinfo") as mock_dns:
            mock_dns.return_value = [(None, None, None, None, ("93.184.216.34", 0))]
            assert is_public_http_url("https://example.com/careers") is True

    def test_fails_closed_when_dns_resolution_fails(self) -> None:
        with patch("openjobradar.poll.http.socket.getaddrinfo", side_effect=OSError("no dns")):
            assert is_public_http_url("https://nonexistent.invalid/") is False


def test_http_error_message_includes_detail() -> None:
    err = HttpError(404, "https://example.com", "board not found")
    assert "404" in str(err)
    assert "board not found" in str(err)


def test_blocked_url_error_message_includes_reason() -> None:
    err = BlockedUrlError("https://169.254.169.254/", "private address")
    assert "private address" in str(err)