feat(file): report a rejected file extension clearly on upload

- translate MediaWiki filetype-banned errors into a readable ValueError
- name the offending extension and list the extensions the wiki accepts
- re-raise every other APIError unchanged
- closes #51

Author: LukasGold

src/osw/controller/file/wiki.py

@@ -2,13 +2,50 @@
 import os
 from typing import IO, Any, Dict, List, Optional
 
+import mwclient.errors
+
 from osw.controller.file.base import FileController
 from osw.controller.file.remote import RemoteFileController
 from osw.core import OSW, model
 from osw.utils.wiki import get_namespace, get_title
 from osw.wtsite import WtSite
 
 
+def get_allowed_file_extensions(mw_site) -> Optional[List[str]]:
+    """Queries the file extensions the wiki accepts, None if unavailable"""
+    try:
+        result = mw_site.api(
+            "query", meta="siteinfo", siprop="fileextensions", formatversion=2
+        )
+    except Exception:
+        # only used to enrich an error message, never worth failing over
+        return None
+    extensions = result.get("query", {}).get("fileextensions", [])
+    return [entry["ext"] for entry in extensions if "ext" in entry]
+
+
+def reraise_upload_error(
+    error: mwclient.errors.APIError, mw_site, title: str, suffix: Optional[str]
+) -> None:
+    """Turns a rejected file extension into a readable error, re-raises the rest
+
+    MediaWiki reports a rejected extension as filetype-banned,
+    filetype-banned-type or filetype-badtype, depending on the version.
+    """
+    if "filetype" not in str(getattr(error, "code", "")):
+        raise error
+    allowed = get_allowed_file_extensions(mw_site)
+    hint = (
+        f" Extensions allowed on this wiki: {', '.join(sorted(allowed))}."
+        if allowed
+        else ""
+    )
+    raise ValueError(
+        f"Upload of '{title}' was rejected because the file extension "
+        f"'{suffix}' is not allowed on {mw_site.host}.{hint}"
+    ) from error
+
+
 class WikiFileController(model.WikiFile, RemoteFileController):
     """File controller for wiki files"""
 
@@ -138,13 +175,16 @@ def put(self, file: IO, **kwargs: Dict[str, Any]):
                 **se_params,
             )
         )
-        self.osw.mw_site.upload(
-            file=file,
-            filename=self.title,
-            # comment="",
-            # description="",
-            ignore=True,
-        )
+        try:
+            self.osw.mw_site.upload(
+                file=file,
+                filename=self.title,
+                # comment="",
+                # description="",
+                ignore=True,
+            )
+        except mwclient.errors.APIError as e:
+            reraise_upload_error(e, self.osw.mw_site, self.title, self.suffix)
 
     def put_from(self, other: FileController, **kwargs: Dict[str, Any]):
         # if isinstance(file, LocalFileController) and self.suffix is None:

tests/test_wiki_file_upload_errors.py

@@ -0,0 +1,87 @@
+"""Unit tests for upload error reporting in osw.controller.file.wiki.
+
+Regression guard for #51: a file rejected because of its extension must produce
+an error that names the extension, instead of a bare MediaWiki API code.
+"""
+
+import mwclient.errors
+import pytest
+
+from osw.controller.file.wiki import (
+    get_allowed_file_extensions,
+    reraise_upload_error,
+)
+
+
+class _FakeSite:
+    host = "wiki.example.org"
+
+    def __init__(self, extensions=None, fail=False):
+        self._extensions = extensions
+        self._fail = fail
+
+    def api(self, *args, **kwargs):
+        if self._fail:
+            raise RuntimeError("siteinfo unavailable")
+        return {"query": {"fileextensions": [{"ext": e} for e in self._extensions]}}
+
+
+def _api_error(code):
+    return mwclient.errors.APIError(code, "info", {})
+
+
+@pytest.mark.parametrize(
+    "code", ["filetype-banned", "filetype-banned-type", "filetype-badtype"]
+)
+def test_rejected_extension_names_the_extension(code):
+    site = _FakeSite(extensions=["png", "pdf"])
+
+    with pytest.raises(ValueError) as exc_info:
+        reraise_upload_error(_api_error(code), site, "OSW123.exe", ".exe")
+
+    message = str(exc_info.value)
+    assert ".exe" in message
+    assert "OSW123.exe" in message
+    assert "wiki.example.org" in message
+    assert "pdf, png" in message  # allowed extensions, sorted
+
+
+def test_original_error_is_chained():
+    site = _FakeSite(extensions=["png"])
+    original = _api_error("filetype-banned")
+
+    with pytest.raises(ValueError) as exc_info:
+        reraise_upload_error(original, site, "OSW123.exe", ".exe")
+
+    assert exc_info.value.__cause__ is original
+
+
+def test_unrelated_api_error_is_reraised_unchanged():
+    site = _FakeSite(extensions=["png"])
+    original = _api_error("readapidenied")
+
+    with pytest.raises(mwclient.errors.APIError) as exc_info:
+        reraise_upload_error(original, site, "OSW123.png", ".png")
+
+    assert exc_info.value is original
+
+
+def test_message_omits_the_hint_when_siteinfo_fails():
+    """A failing siteinfo lookup must not mask the upload error."""
+    site = _FakeSite(fail=True)
+
+    with pytest.raises(ValueError) as exc_info:
+        reraise_upload_error(_api_error("filetype-banned"), site, "a.exe", ".exe")
+
+    assert "allowed on this wiki" not in str(exc_info.value)
+    assert ".exe" in str(exc_info.value)
+
+
+def test_get_allowed_file_extensions_returns_none_on_failure():
+    assert get_allowed_file_extensions(_FakeSite(fail=True)) is None
+
+
+def test_get_allowed_file_extensions_reads_siteinfo():
+    site = _FakeSite(extensions=["png", "jpg"])
+
+    assert get_allowed_file_extensions(site) == ["png", "jpg"]