Add error handling for connectivity issues in filters latest_volto and latest_plone (Fixes #110)

Author: ericof

cookieplone/filters/__init__.py

@@ -73,14 +73,14 @@ def use_prerelease_versions(_: str) -> str:
 def latest_volto(use_prerelease_versions: str) -> str:
     """Return the latest released version of Volto."""
     allow_prerelease = parse_boolean(use_prerelease_versions)
-    return versions.latest_volto(allow_prerelease=allow_prerelease)
+    return versions.latest_volto(allow_prerelease=allow_prerelease) or ""
 
 
 @simple_filter
 def latest_plone(use_prerelease_versions: str) -> str:
     """Return the latest released version of Plone."""
     allow_prerelease = parse_boolean(use_prerelease_versions)
-    return versions.latest_plone(allow_prerelease=allow_prerelease)
+    return versions.latest_plone(allow_prerelease=allow_prerelease) or ""
 
 
 @simple_filter

cookieplone/settings.py

@@ -73,3 +73,6 @@ class PythonVersionSupport:
 REPO_LOCATION = "COOKIEPLONE_REPOSITORY"
 REPO_TAG = "COOKIEPLONE_REPOSITORY_TAG"
 REPO_PASSWORD = "COOKIEPLONE_REPO_PASSWORD"  # noQA:S105
+
+# Connectivity
+REQUESTS_TIMEOUT = 10

cookieplone/utils/versions.py

@@ -46,8 +46,10 @@ def convert_pep440_semver(version: str) -> str:
 def get_npm_package_versions(package: str) -> list[str]:
     """Get versions for a npm package."""
     url: str = f"https://registry.npmjs.org/{package}"
-    resp = requests.get(  # noQA: S113
-        url, headers={"Accept": "application/vnd.npm.install-v1+json"}
+    resp = requests.get(
+        url,
+        headers={"Accept": "application/vnd.npm.install-v1+json"},
+        timeout=settings.REQUESTS_TIMEOUT,
     )
     data = resp.json()
     return list(data["dist-tags"].values())
@@ -56,7 +58,7 @@ def get_npm_package_versions(package: str) -> list[str]:
 def get_pypi_package_versions(package: str) -> list[str]:
     """Get versions for a PyPi package."""
     url: str = f"https://pypi.org/pypi/{package}/json"
-    resp = requests.get(url)  # noQA: S113
+    resp = requests.get(url, timeout=settings.REQUESTS_TIMEOUT)
     data = resp.json()
     return list(data.get("releases").keys())
 
@@ -84,15 +86,15 @@ def version_latest(
     max_version: str | None = None,
     allow_prerelease: bool = False,
 ) -> str | None:
-    min_version = Version(min_version) if min_version else None
-    max_version = Version(max_version) if max_version else None
+    min_version_ = Version(min_version) if min_version else None
+    max_version_ = Version(max_version) if max_version else None
     versions_ = sorted(
         [(Version(v.replace("v", "")), v) for v in versions], reverse=True
     )
     valid = [
         (version, raw_version)
         for version, raw_version in versions_
-        if is_valid_version(version, min_version, max_version, allow_prerelease)
+        if is_valid_version(version, min_version_, max_version_, allow_prerelease)
     ]
     return valid[0][1] if valid else None
 
@@ -103,7 +105,10 @@ def latest_volto(
     allow_prerelease: bool = False,
 ) -> str | None:
     """Return the latest volto version."""
-    versions = get_npm_package_versions("@plone/volto")
+    try:
+        versions = get_npm_package_versions("@plone/volto")
+    except requests.RequestException:
+        versions = []
     return version_latest(
         versions,
         min_version=min_version,
@@ -118,7 +123,11 @@ def latest_plone(
     allow_prerelease: bool = False,
 ) -> str | None:
     """Return the latest Plone version."""
-    versions = get_pypi_package_versions("Plone")
+
+    try:
+        versions = get_pypi_package_versions("Plone")
+    except requests.RequestException:
+        versions = []
     return version_latest(
         versions,
         min_version=min_version,
@@ -138,7 +147,7 @@ def python_versions_for_plone(plone_version: str) -> settings.PythonVersionSuppo
     major = Version(plone_version).major
     minor = Version(plone_version).minor
     version = f"{major}.{minor}"
-    return settings.PLONE_PYTHON.get(version)
+    return settings.PLONE_PYTHON[version]
 
 
 def python_version_for_plone(plone_version: str) -> str:

news/110.bugfix

@@ -0,0 +1 @@
+Add error handling for connectivity issues in filters `latest_volto` and `latest_plone`. @ericof

tests/utils/test_versions.py

@@ -113,6 +113,17 @@ def get_pypi_package_versions(*args, **kwargs):
     )
 
 
+@pytest.fixture
+def mock_packages_with_raise(monkeypatch, volto_versions):
+    import requests
+
+    def get_package_versions(*args, **kwargs):
+        raise requests.ConnectionError("Unable to connect")
+
+    monkeypatch.setattr(versions, "get_npm_package_versions", get_package_versions)
+    monkeypatch.setattr(versions, "get_pypi_package_versions", get_package_versions)
+
+
 @pytest.mark.parametrize(
     "version,min_version,max_version,allow_prerelease,expected",
     [
@@ -202,6 +213,28 @@ def test_latest_volto(
     assert func(min_version, max_version, allow_prerelease) == expected
 
 
+@pytest.mark.parametrize(
+    "min_version,max_version,allow_prerelease,expected",
+    [
+        [None, None, True, None],
+        [None, None, False, None],
+        ["17", None, False, None],
+        ["17", "18", False, None],
+        ["17", "18", True, None],
+        ["17", "17.99", True, None],
+    ],
+)
+def test_latest_volto_no_connection(
+    mock_packages_with_raise,
+    min_version: str,
+    max_version: str,
+    allow_prerelease: bool,
+    expected: str,
+):
+    func = versions.latest_volto
+    assert func(min_version, max_version, allow_prerelease) == expected
+
+
 @pytest.mark.parametrize(
     "min_version,max_version,allow_prerelease,expected",
     [
@@ -223,6 +256,27 @@ def test_latest_plone(
     assert func(min_version, max_version, allow_prerelease) == expected
 
 
+@pytest.mark.parametrize(
+    "min_version,max_version,allow_prerelease,expected",
+    [
+        [None, None, False, None],
+        [None, None, True, None],
+        [None, "5.99", False, None],
+        ["5", "5.2", False, None],
+        ["5", "6", False, None],
+    ],
+)
+def test_latest_plone_no_connection(
+    mock_packages_with_raise,
+    min_version: str,
+    max_version: str,
+    allow_prerelease: bool,
+    expected: str,
+):
+    func = versions.latest_plone
+    assert func(min_version, max_version, allow_prerelease) == expected
+
+
 @pytest.mark.parametrize(
     "plone_version,supported,earliest,latest",
     [