mkdocs2confluence 0.9.5__tar.gz → 0.9.7__tar.gz

{mkdocs2confluence-0.9.5 → mkdocs2confluence-0.9.7}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: mkdocs2confluence
-Version: 0.9.5
+Version: 0.9.7
 Summary: Publish MkDocs Material pages to Confluence Cloud — admonitions, Mermaid diagrams, tabs, page properties and more
 Author: Anders Hybertz
 License: GPL-3.0-or-later

{mkdocs2confluence-0.9.5 → mkdocs2confluence-0.9.7}/pyproject.toml

@@ -1,6 +1,6 @@
 [project]
 name = "mkdocs2confluence"
-version = "0.9.5"
+version = "0.9.7"
 description = "Publish MkDocs Material pages to Confluence Cloud — admonitions, Mermaid diagrams, tabs, page properties and more"
 readme = "README.md"
 license = { text = "GPL-3.0-or-later" }

{mkdocs2confluence-0.9.5 → mkdocs2confluence-0.9.7}/src/mkdocs2confluence.egg-info/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: mkdocs2confluence
-Version: 0.9.5
+Version: 0.9.7
 Summary: Publish MkDocs Material pages to Confluence Cloud — admonitions, Mermaid diagrams, tabs, page properties and more
 Author: Anders Hybertz
 License: GPL-3.0-or-later

{mkdocs2confluence-0.9.5 → mkdocs2confluence-0.9.7}/src/mkdocs_to_confluence/transforms/mermaid.py

@@ -99,9 +99,10 @@ def _render_one(source: str, kroki_url: str, *, quiet: bool = False) -> Path | N
     Transient HTTP errors (429, 5xx) and network blips are retried up to
     ``_RETRY_ATTEMPTS`` times with exponential backoff.
 
-    When using the public kroki.io and all retries are exhausted due to 504s,
-    one final attempt is made via mermaid.ink before giving up.  Self-hosted
-    Kroki instances never fall back to mermaid.ink.
+    When using the public kroki.io and all retries are exhausted due to kroki
+    being unreachable (504 or timeout), one final attempt is made via
+    mermaid.ink before giving up.  Self-hosted Kroki instances never fall back
+    to mermaid.ink.
     """
     path = _cache_path(source)
     if path.exists():
@@ -111,7 +112,7 @@ def _render_one(source: str, kroki_url: str, *, quiet: bool = False) -> Path | N
 
     use_public_kroki = kroki_url.rstrip("/") == DEFAULT_KROKI_URL.rstrip("/")
     last_exc: Exception | None = None
-    last_was_504 = False
+    kroki_unavailable = False  # True when kroki is unreachable (504 or timeout)
 
     for attempt in range(_RETRY_ATTEMPTS):
         if attempt > 0:
@@ -130,22 +131,24 @@ def _render_one(source: str, kroki_url: str, *, quiet: bool = False) -> Path | N
         except urllib.error.HTTPError as exc:
             if exc.code in _RETRYABLE_HTTP:
                 last_exc = exc
-                last_was_504 = exc.code == 504
+                kroki_unavailable = exc.code == 504
                 continue  # retry
             _warn(f"mermaid diagram: Kroki returned HTTP {exc.code} {exc.reason} — falling back to code block")
             return None
-        except urllib.error.URLError as exc:
+        except (urllib.error.URLError, OSError) as exc:
+            # URLError covers connection errors; OSError covers read-phase timeouts
+            # (socket.timeout is OSError but not URLError when raised by resp.read()).
             last_exc = exc
-            last_was_504 = False
+            kroki_unavailable = True
             continue  # retry — network blip
-        except (OSError, ValueError) as exc:
+        except ValueError as exc:
             _warn(f"mermaid diagram: {exc} — falling back to code block")
             return None
 
-    # All Kroki retries exhausted — try mermaid.ink if on public kroki.io and last error was 504.
-    if use_public_kroki and last_was_504:
+    # All Kroki retries exhausted — try mermaid.ink if on public kroki.io and kroki was unreachable.
+    if use_public_kroki and kroki_unavailable:
         try:
-            _warn("mermaid diagram: kroki.io unavailable (504), trying mermaid.ink as fallback")
+            _warn("mermaid diagram: kroki.io unreachable, trying mermaid.ink as fallback")
             png = _mermaid_ink_png(source)
             if len(png) < _MIN_PNG_BYTES:
                 raise ValueError(f"mermaid.ink returned {len(png)} bytes (expected a valid PNG)")

{mkdocs2confluence-0.9.5 → mkdocs2confluence-0.9.7}/tests/test_mermaid.py

@@ -102,7 +102,7 @@ def test_render_deduplicates_identical_diagrams(tmp_path):
 
 
 def test_render_fallback_on_network_error(tmp_path, capsys):
-    """When Kroki is unreachable, node is left unchanged (code block fallback)."""
+    """When Kroki is unreachable and mermaid.ink also fails, node falls back to code block."""
     import urllib.error
 
     node = MermaidDiagram(source=_SAMPLE_SOURCE)
@@ -114,6 +114,10 @@ def test_render_fallback_on_network_error(tmp_path, capsys):
             "mkdocs_to_confluence.transforms.mermaid._kroki_png",
             side_effect=urllib.error.URLError("timed out"),
         ),
+        patch(
+            "mkdocs_to_confluence.transforms.mermaid._mermaid_ink_png",
+            side_effect=urllib.error.URLError("timed out"),
+        ),
     ):
         updated_nodes, attachments = render_mermaid_diagrams((node,))
 
@@ -218,7 +222,7 @@ def test_render_multiple_diagrams_concurrently(tmp_path):
 
 
 def test_render_one_failure_does_not_block_others(tmp_path):
-    """If one diagram fails, the rest still render successfully."""
+    """If one diagram fails (both kroki and mermaid.ink), the rest still render successfully."""
     import urllib.error
 
     good_source = "graph TD\n    A --> B\n"
@@ -231,7 +235,9 @@ def test_render_one_failure_does_not_block_others(tmp_path):
         return _FAKE_PNG
 
     with patch("mkdocs_to_confluence.transforms.mermaid._CACHE_DIR", tmp_path), \
-         patch("mkdocs_to_confluence.transforms.mermaid._kroki_png", side_effect=fake_kroki):
+         patch("mkdocs_to_confluence.transforms.mermaid._kroki_png", side_effect=fake_kroki), \
+         patch("mkdocs_to_confluence.transforms.mermaid._mermaid_ink_png",
+               side_effect=urllib.error.URLError("timeout")):
         updated, attachments = render_mermaid_diagrams(nodes)
 
     # One attachment for the successful diagram
@@ -258,7 +264,7 @@ def test_render_one_cached(tmp_path):
 
 
 def test_render_one_network_failure_returns_none(tmp_path):
-    """_render_one returns None after all retries on persistent network failure."""
+    """_render_one returns None after all retries when both kroki and mermaid.ink fail."""
     import urllib.error
 
     from mkdocs_to_confluence.transforms.mermaid import _render_one
@@ -266,6 +272,8 @@ def test_render_one_network_failure_returns_none(tmp_path):
     with patch("mkdocs_to_confluence.transforms.mermaid._CACHE_DIR", tmp_path), \
          patch("mkdocs_to_confluence.transforms.mermaid.time.sleep"), \
          patch("mkdocs_to_confluence.transforms.mermaid._kroki_png",
+               side_effect=urllib.error.URLError("connection refused")), \
+         patch("mkdocs_to_confluence.transforms.mermaid._mermaid_ink_png",
                side_effect=urllib.error.URLError("connection refused")):
         result = _render_one(_SAMPLE_SOURCE, "https://kroki.io")
 
@@ -371,7 +379,7 @@ def test_render_mermaid_cached_quiet_suppresses_stdout(tmp_path, capsys):
 
 
 def test_render_one_504_on_public_kroki_falls_back_to_mermaid_ink(tmp_path, capsys):
-    """Public kroki.io 504 → automatic fallback to mermaid.ink for Mermaid."""
+    """Public kroki.io 504 → automatic fallback to mermaid.ink."""
     import urllib.error
 
     from mkdocs_to_confluence.transforms.mermaid import _render_one
@@ -389,6 +397,44 @@ def test_render_one_504_on_public_kroki_falls_back_to_mermaid_ink(tmp_path, caps
     mock_ink.assert_called_once_with(_SAMPLE_SOURCE)
 
 
+def test_render_one_timeout_on_public_kroki_falls_back_to_mermaid_ink(tmp_path):
+    """Public kroki.io URLError timeout → automatic fallback to mermaid.ink."""
+    import urllib.error
+
+    from mkdocs_to_confluence.transforms.mermaid import _render_one
+
+    with patch("mkdocs_to_confluence.transforms.mermaid._CACHE_DIR", tmp_path), \
+         patch("mkdocs_to_confluence.transforms.mermaid.time.sleep"), \
+         patch("mkdocs_to_confluence.transforms.mermaid._kroki_png",
+               side_effect=urllib.error.URLError("timed out")), \
+         patch("mkdocs_to_confluence.transforms.mermaid._mermaid_ink_png",
+               return_value=_FAKE_PNG) as mock_ink:
+        result = _render_one(_SAMPLE_SOURCE, "https://kroki.io")
+
+    assert result is not None
+    assert result.exists()
+    mock_ink.assert_called_once_with(_SAMPLE_SOURCE)
+
+
+def test_render_one_read_phase_timeout_falls_back_to_mermaid_ink(tmp_path):
+    """socket.timeout during resp.read() (OSError, not URLError) → fallback to mermaid.ink."""
+    import socket
+
+    from mkdocs_to_confluence.transforms.mermaid import _render_one
+
+    with patch("mkdocs_to_confluence.transforms.mermaid._CACHE_DIR", tmp_path), \
+         patch("mkdocs_to_confluence.transforms.mermaid.time.sleep"), \
+         patch("mkdocs_to_confluence.transforms.mermaid._kroki_png",
+               side_effect=socket.timeout("The read operation timed out")), \
+         patch("mkdocs_to_confluence.transforms.mermaid._mermaid_ink_png",
+               return_value=_FAKE_PNG) as mock_ink:
+        result = _render_one(_SAMPLE_SOURCE, "https://kroki.io")
+
+    assert result is not None
+    assert result.exists()
+    mock_ink.assert_called_once_with(_SAMPLE_SOURCE)
+
+
 def test_render_one_504_on_self_hosted_kroki_does_not_fall_back(tmp_path):
     """Self-hosted Kroki 504 → no mermaid.ink fallback (privacy isolation)."""
     import urllib.error
@@ -407,6 +453,42 @@ def test_render_one_504_on_self_hosted_kroki_does_not_fall_back(tmp_path):
     mock_ink.assert_not_called()
 
 
+def test_render_one_timeout_on_self_hosted_kroki_does_not_fall_back(tmp_path):
+    """Self-hosted Kroki URLError timeout → no mermaid.ink fallback (privacy isolation)."""
+    import urllib.error
+
+    from mkdocs_to_confluence.transforms.mermaid import _render_one
+
+    with patch("mkdocs_to_confluence.transforms.mermaid._CACHE_DIR", tmp_path), \
+         patch("mkdocs_to_confluence.transforms.mermaid.time.sleep"), \
+         patch("mkdocs_to_confluence.transforms.mermaid._kroki_png",
+               side_effect=urllib.error.URLError("timed out")), \
+         patch("mkdocs_to_confluence.transforms.mermaid._mermaid_ink_png",
+               return_value=_FAKE_PNG) as mock_ink:
+        result = _render_one(_SAMPLE_SOURCE, "https://my-internal-kroki.corp")
+
+    assert result is None
+    mock_ink.assert_not_called()
+
+
+def test_render_one_read_phase_timeout_self_hosted_does_not_fall_back(tmp_path):
+    """socket.timeout on self-hosted Kroki → no mermaid.ink fallback (privacy isolation)."""
+    import socket
+
+    from mkdocs_to_confluence.transforms.mermaid import _render_one
+
+    with patch("mkdocs_to_confluence.transforms.mermaid._CACHE_DIR", tmp_path), \
+         patch("mkdocs_to_confluence.transforms.mermaid.time.sleep"), \
+         patch("mkdocs_to_confluence.transforms.mermaid._kroki_png",
+               side_effect=socket.timeout("The read operation timed out")), \
+         patch("mkdocs_to_confluence.transforms.mermaid._mermaid_ink_png",
+               return_value=_FAKE_PNG) as mock_ink:
+        result = _render_one(_SAMPLE_SOURCE, "https://my-internal-kroki.corp")
+
+    assert result is None
+    mock_ink.assert_not_called()
+
+
 def test_render_one_mermaid_ink_fallback_also_fails_returns_none(tmp_path, capsys):
     """When mermaid.ink fallback also fails, returns None (code-block fallback)."""
     import urllib.error