fix: robots.txt- und Drossel-Einstellung speichern und beim Oeffnen anzeigen

Author: michaelblaess

src/console_error_scanner/app.py

@@ -1347,15 +1347,21 @@ def action_show_settings(self) -> None:
             "language": self._settings.language,
             "accept_consent": self._settings.accept_consent,
             "trigger_lazy_load": self._settings.trigger_lazy_load,
+            "respect_robots": self._settings.respect_robots,
             "concurrency": self._settings.concurrency,
+            "rate_limit_enabled": self._settings.rate_limit_enabled,
+            "rate_per_minute": self._settings.rate_per_minute,
             "timeout": self._settings.timeout,
             "console_level": self._settings.console_level,
             "show_preview": self._settings.show_preview,
             "no_headless": self._settings.no_headless,
+            "size_warn_mb": self._settings.size_warn_mb,
+            "score_error_weight": self._settings.score_error_weight,
             "user_agent": self._settings.user_agent,
             "cookies": self._settings.cookies,
             "whitelist_path": self._settings.whitelist_path,
             "proxy_url": self._settings.proxy_url,
+            "jira_format": self._settings.jira_format,
         }
         self.push_screen(
             ScannerSettingsScreen(current, lang=current_language()),
@@ -1377,7 +1383,9 @@ def _on_settings_closed(self, result: dict[str, object] | None) -> None:
             "language": self._settings.language,
             "accept_consent": self._settings.accept_consent,
             "trigger_lazy_load": self._settings.trigger_lazy_load,
+            "respect_robots": self._settings.respect_robots,
             "concurrency": self._settings.concurrency,
+            "rate_limit_enabled": self._settings.rate_limit_enabled,
             "timeout": self._settings.timeout,
             "console_level": self._settings.console_level,
             "show_preview": self._settings.show_preview,
@@ -1393,7 +1401,10 @@ def _on_settings_closed(self, result: dict[str, object] | None) -> None:
         self._settings.language = str(result.get("language", self._settings.language))
         self._settings.accept_consent = bool(result.get("accept_consent", self._settings.accept_consent))
         self._settings.trigger_lazy_load = bool(result.get("trigger_lazy_load", self._settings.trigger_lazy_load))
+        self._settings.respect_robots = bool(result.get("respect_robots", self._settings.respect_robots))
         self._settings.concurrency = int(result.get("concurrency", self._settings.concurrency))  # type: ignore[arg-type]
+        self._settings.rate_limit_enabled = bool(result.get("rate_limit_enabled", self._settings.rate_limit_enabled))
+        self._settings.rate_per_minute = int(result.get("rate_per_minute", self._settings.rate_per_minute))  # type: ignore[arg-type]
         self._settings.timeout = int(result.get("timeout", self._settings.timeout))  # type: ignore[arg-type]
         self._settings.console_level = str(result.get("console_level", self._settings.console_level))
         self._settings.show_preview = bool(result.get("show_preview", self._settings.show_preview))
@@ -1406,11 +1417,13 @@ def _on_settings_closed(self, result: dict[str, object] | None) -> None:
             str(result.get("score_error_weight", self._settings.score_error_weight))
         )
         self._settings.proxy_url = str(result.get("proxy_url", self._settings.proxy_url))
+        self._settings.jira_format = str(result.get("jira_format", self._settings.jira_format))
         self._settings.save()
 
         # Runtime-Werte fuer den naechsten Scan aktualisieren
         self.accept_consent = self._settings.accept_consent
         self.trigger_lazy_load = self._settings.trigger_lazy_load
+        self.respect_robots = self._settings.respect_robots
         self.concurrency = self._settings.concurrency
         self.rate_per_minute = self._settings.rate_per_minute if self._settings.rate_limit_enabled else 0
         self.timeout = self._settings.timeout
@@ -1437,7 +1450,9 @@ def _on_settings_closed(self, result: dict[str, object] | None) -> None:
             ("language", t("binding.settings") + " (Lang)"),
             ("accept_consent", t("settings.consent_label")),
             ("trigger_lazy_load", t("settings.scroll_label")),
+            ("respect_robots", t("settings.robots_label")),
             ("concurrency", t("settings.concurrency_label")),
+            ("rate_limit_enabled", t("settings.rate_label")),
             ("timeout", t("settings.timeout_label")),
             ("console_level", t("settings.console_level_label")),
             ("show_preview", t("settings.preview_label")),

tests/test_settings_roundtrip.py

@@ -0,0 +1,64 @@
+"""Regression: Scanner-Einstellungen ueberleben Speichern + erneutes Oeffnen.
+
+Deckt den Bug ab, bei dem 'robots.txt beachten' und 'Aufrufe drosseln' nach dem
+Speichern wieder angehakt waren: die App reichte diese Felder weder in den Dialog
+hinein (action_show_settings) noch aus dem Ergebnis zurueck in die persistierten
+Einstellungen (_on_settings_closed). Der reine to_dict()-Roundtrip in
+test_safe_defaults deckte das NICHT ab, weil er das App-Mapping ueberspringt.
+"""
+
+from __future__ import annotations
+
+import asyncio
+from pathlib import Path
+
+from textual.widgets import Checkbox
+
+from console_error_scanner import app as app_module
+from console_error_scanner.app import ConsoleErrorScannerApp
+from console_error_scanner.i18n import load_locale
+from console_error_scanner.models import settings as settings_module
+from console_error_scanner.models.settings import Settings
+
+
+def _isolate(tmp_path: Path, monkeypatch: object) -> Path:
+    """Verlegt die settings.json in tmp_path und ueberspringt den Disclaimer."""
+    settings_file = tmp_path / "settings.json"
+    monkeypatch.setattr(settings_module, "SETTINGS_DIR", tmp_path)  # type: ignore[attr-defined]
+    monkeypatch.setattr(settings_module, "SETTINGS_FILE", settings_file)  # type: ignore[attr-defined]
+    monkeypatch.setattr(Settings, "SETTINGS_DIR", tmp_path)  # type: ignore[attr-defined]
+    monkeypatch.setattr(Settings, "SETTINGS_FILE", settings_file)  # type: ignore[attr-defined]
+    monkeypatch.setattr(app_module, "SETTINGS_FILE", settings_file)  # type: ignore[attr-defined]
+    monkeypatch.setattr(ConsoleErrorScannerApp, "_ask_disclaimer", lambda self: None)  # type: ignore[attr-defined]
+    load_locale("de")
+    return settings_file
+
+
+def test_robots_and_rate_survive_save_and_reopen(tmp_path: Path, monkeypatch: object) -> None:
+    _isolate(tmp_path, monkeypatch)
+
+    async def drive() -> None:
+        app = ConsoleErrorScannerApp()
+        async with app.run_test() as pilot:
+            app.action_show_settings()
+            await pilot.pause()
+            app.screen.query_one("#set-robots", Checkbox).value = False
+            app.screen.query_one("#set-rate-on", Checkbox).value = False
+            await pilot.pause()
+            await pilot.press("ctrl+s")
+            await pilot.pause()
+
+            # Erneut oeffnen: der Dialog muss den gespeicherten Zustand zeigen
+            # (deckt das fehlende Feld im current-Dict ab).
+            app.action_show_settings()
+            await pilot.pause()
+            assert app.screen.query_one("#set-robots", Checkbox).value is False
+            assert app.screen.query_one("#set-rate-on", Checkbox).value is False
+
+    asyncio.run(drive())
+
+    # Und auf der Platte gelandet (deckt das fehlende Mapping in
+    # _on_settings_closed ab).
+    reloaded = Settings.load()
+    assert reloaded.respect_robots is False
+    assert reloaded.rate_limit_enabled is False