fix: harden catalog edge cases

Author: xxg1413

tests/test_catalog.py

@@ -5,7 +5,12 @@
 
 import pytest
 
-from tools.catalog import CatalogLoadError, load_catalog, validate_catalog
+from tools.catalog import (
+    CatalogLoadError,
+    load_catalog,
+    normalize_url,
+    validate_catalog,
+)
 from tools.validate_catalog import run
 
 
@@ -49,6 +54,23 @@ def test_resource_ids_and_urls_reject_unsafe_forms(valid_catalog: dict) -> None:
     assert {"invalid-id", "url-credentials"} <= codes
 
 
+@pytest.mark.parametrize(
+    ("url", "expected"),
+    [
+        (
+            "HTTPS://[2001:4860:4860::8888]:443/docs/",
+            "https://[2001:4860:4860::8888]/docs",
+        ),
+        (
+            "https://[2001:4860:4860::8888]:8443/docs/",
+            "https://[2001:4860:4860::8888]:8443/docs",
+        ),
+    ],
+)
+def test_normalize_url_preserves_ipv6_brackets(url: str, expected: str) -> None:
+    assert normalize_url(url) == expected
+
+
 def test_validator_exit_code_for_invalid_catalog(tmp_path) -> None:
     catalog = tmp_path / "resources.yml"
     catalog.write_text("catalog: {}\nresources: []\n", encoding="utf-8")

tests/test_check_links.py

@@ -265,6 +265,39 @@ def head(self, url, **kwargs):
     assert "programming defect" in (result.error or "")
 
 
+def test_responses_close_when_result_processing_fails(monkeypatch) -> None:
+    head = FakeResponse(404)
+    response = FakeResponse(200)
+    session = FakeSession(head, response)
+    checker = LinkChecker(
+        guard=guard_for(), session_factory=lambda: session, workers=1, min_interval=0
+    )
+
+    def fail_history(_response):
+        raise RuntimeError("cannot process response")
+
+    monkeypatch.setattr(check_links, "_history", fail_history)
+    result = checker.check_one(link())
+
+    assert result.status == "error"
+    assert head.closed is True
+    assert response.closed is True
+
+
+@pytest.mark.parametrize(
+    ("option", "value"),
+    [
+        ("--timeout", "nan"),
+        ("--timeout", "inf"),
+        ("--backoff", "nan"),
+        ("--min-interval", "inf"),
+    ],
+)
+def test_cli_rejects_non_finite_float_arguments(option: str, value: str) -> None:
+    with pytest.raises(SystemExit, match="2"):
+        check_links.build_parser().parse_args([option, value])
+
+
 @pytest.mark.parametrize(
     ("status", "status_code", "expected_exit"),
     [

tools/catalog.py

@@ -104,9 +104,10 @@ def normalize_url(value: str) -> str:
     default_port = (parsed.scheme.lower() == "https" and port == 443) or (
         parsed.scheme.lower() == "http" and port == 80
     )
-    netloc = host
+    display_host = f"[{host}]" if ":" in host else host
+    netloc = display_host
     if port and not default_port:
-        netloc = f"{host}:{port}"
+        netloc = f"{display_host}:{port}"
     path = parsed.path or "/"
     if path != "/":
         path = path.rstrip("/")

tools/check_links.py

@@ -6,6 +6,7 @@
 import argparse
 import ipaddress
 import json
+import math
 import socket
 import sys
 import threading
@@ -321,38 +322,39 @@ def check_one(self, link: CatalogLink) -> LinkResult:
             self.guard.resolve_url(link.url)
             session = self.sessions.get()
             head = self._request(session, "HEAD", link.url)
-            if head.status_code < 400:
-                history = _history(head)
-                result = LinkResult(
+            try:
+                if head.status_code < 400:
+                    history = _history(head)
+                    return LinkResult(
+                        link.id,
+                        link.path,
+                        link.title,
+                        link.url,
+                        classify_status(head.status_code, redirected=bool(history)),
+                        status_code=head.status_code,
+                        method="HEAD",
+                        final_url=head.url,
+                        history=history,
+                    )
+            finally:
+                head.close()
+
+            response = self._request(session, "GET", link.url)
+            try:
+                history = _history(response)
+                return LinkResult(
                     link.id,
                     link.path,
                     link.title,
                     link.url,
-                    classify_status(head.status_code, redirected=bool(history)),
-                    status_code=head.status_code,
-                    method="HEAD",
-                    final_url=head.url,
+                    classify_status(response.status_code, redirected=bool(history)),
+                    status_code=response.status_code,
+                    method="GET",
+                    final_url=response.url,
                     history=history,
                 )
-                head.close()
-                return result
-            head.close()
-
-            response = self._request(session, "GET", link.url)
-            history = _history(response)
-            result = LinkResult(
-                link.id,
-                link.path,
-                link.title,
-                link.url,
-                classify_status(response.status_code, redirected=bool(history)),
-                status_code=response.status_code,
-                method="GET",
-                final_url=response.url,
-                history=history,
-            )
-            response.close()
-            return result
+            finally:
+                response.close()
         except UnsafeTarget as exc:
             return LinkResult(
                 link.id, link.path, link.title, link.url, "blocked", error=str(exc)
@@ -451,15 +453,15 @@ def exit_code_for_report(report: Mapping[str, Any]) -> int:
 
 def _positive_float(value: str) -> float:
     parsed = float(value)
-    if parsed <= 0:
-        raise argparse.ArgumentTypeError("must be greater than zero")
+    if not math.isfinite(parsed) or parsed <= 0:
+        raise argparse.ArgumentTypeError("must be a finite number greater than zero")
     return parsed
 
 
 def _non_negative_float(value: str) -> float:
     parsed = float(value)
-    if parsed < 0:
-        raise argparse.ArgumentTypeError("must be zero or greater")
+    if not math.isfinite(parsed) or parsed < 0:
+        raise argparse.ArgumentTypeError("must be a finite number zero or greater")
     return parsed