fix(bugsweep): 3 Bugs behoben – LSP-Stop-Crash, Editor-Selection-Wrap, Enum-Hygiene

Lukas Geiger · claude · Lukas Geiger · commit 9ffc975716f7 · 2026-06-10T13:26:20.000+02:00
Bug B-009 (lsp_client.py): subprocess.TimeoutExpired nach process.kill() wurde nicht
gefangen, was _reader_thread.join() übersprungen hätte. Zweiter wait()-Aufruf jetzt in
try/except eingebettet; finally-Block schließt Streams und setzt self.process = None.

Bug B-010 (core/editor.py): Beim Auto-Close mit aktiver Textauswahl wurde die Auswahl
verworfen statt umschlossen. Jetzt wird selectedText() mit dem Bracket-Paar umhüllt;
U+2029 (Qt-Paragraph-Separator in mehrzeiligen Selections) wird vor dem Einfügen zu \n
normalisiert.

Bug B-008 (ui/main_window.py): closeEvent verwendete veraltete QMessageBox.Yes/No-
Kurznamen statt QMessageBox.StandardButton.Yes/No (Deprecation-Hygiene für PySide6 6.x).

Tests: 8 neue Regression-Tests in 3 Dateien (46+1 skipped gesamt, alles grün).

Co-Authored-By: Claude Sonnet 4.6 &lt;noreply@anthropic.com&gt;
diff --git a/core/editor.py b/core/editor.py
@@ -148,11 +148,16 @@ def keyPressEvent(self, event):
             cursor = self.textCursor()
             pos = cursor.position()
             text = self.toPlainText()
+            # Wrap selection in brackets/quotes instead of discarding it
+            if cursor.hasSelection():
+                selected = cursor.selectedText().replace(' ', '\n')
+                cursor.insertText(event.text() + selected + close_char)
+                self.setTextCursor(cursor)
+                return
             # Skip over existing closing char when open == close (quotes)
             if (event.text() == close_char
                     and pos < len(text)
-                    and text[pos] == close_char
-                    and not cursor.hasSelection()):
+                    and text[pos] == close_char):
                 cursor.movePosition(QTextCursor.MoveOperation.Right)
                 self.setTextCursor(cursor)
                 return
diff --git a/features/lsp_client.py b/features/lsp_client.py
@@ -160,7 +160,10 @@ def stop(self):
                 process.wait(timeout=3)
             except subprocess.TimeoutExpired:
                 process.kill()
-                process.wait(timeout=3)
+                try:
+                    process.wait(timeout=3)
+                except subprocess.TimeoutExpired:
+                    pass
             finally:
                 for stream in (process.stdin, process.stdout, process.stderr):
                     if stream:
diff --git a/tests/test_editor_auto_close.py b/tests/test_editor_auto_close.py
@@ -75,6 +75,46 @@ def test_open_bracket_auto_closes_normally(self):
         self.assertEqual(text, "()", f"Erwartet '()', bekommen: {text!r}")
         self.assertEqual(self.editor.textCursor().position(), 1)
 
+    def test_selection_wrapped_with_brackets(self):
+        """Regression B-010: Markierter Text + ( soll '(text)' ergeben, nicht '()'."""
+        self.editor.setPlainText("hello")
+        cursor = self.editor.textCursor()
+        cursor.setPosition(0)
+        cursor.setPosition(5, cursor.MoveMode.KeepAnchor)
+        self.editor.setTextCursor(cursor)
+
+        self.editor.keyPressEvent(_key_event("("))
+        text = self.editor.toPlainText()
+        self.assertEqual(text, "(hello)", f"Erwartete '(hello)', bekommen: {text!r}")
+
+    def test_selection_wrapped_with_double_quotes(self):
+        """Regression B-010b: Markierter Text + \" soll '\"text\"' ergeben."""
+        self.editor.setPlainText("world")
+        cursor = self.editor.textCursor()
+        cursor.setPosition(0)
+        cursor.setPosition(5, cursor.MoveMode.KeepAnchor)
+        self.editor.setTextCursor(cursor)
+
+        self.editor.keyPressEvent(_key_event('"'))
+        text = self.editor.toPlainText()
+        self.assertEqual(text, '"world"', f"Erwartete '\"world\"', bekommen: {text!r}")
+
+    def test_multiline_selection_wrapped_without_u2029(self):
+        """Regression B-010c: Mehrzeilige Markierung + ( darf kein U+2029 in den Text einfügen.
+        selectedText() liefert U+2029 für Zeilenumbrüche — muss zu \\n normalisiert werden."""
+        self.editor.setPlainText("line1\nline2")
+        cursor = self.editor.textCursor()
+        cursor.setPosition(0)
+        cursor.movePosition(cursor.MoveOperation.End, cursor.MoveMode.KeepAnchor)
+        self.editor.setTextCursor(cursor)
+
+        self.editor.keyPressEvent(_key_event("("))
+        text = self.editor.toPlainText()
+        self.assertNotIn(' ', text,
+                         f"U+2029 darf nicht im Dokument erscheinen: {text!r}")
+        self.assertEqual(text, "(line1\nline2)",
+                         f"Erwartete '(line1\\nline2)', bekommen: {text!r}")
+
 
 if __name__ == "__main__":
     unittest.main()
diff --git a/tests/test_lsp_client.py b/tests/test_lsp_client.py
@@ -52,6 +52,72 @@ def test_unknown_language_is_unavailable(self):
         self.assertIsNone(client._resolve_command())
 
 
+class LSPClientStopRobustnessTests(unittest.TestCase):
+    def test_stop_does_not_raise_when_kill_wait_times_out(self):
+        """Regression B-009: LSPClient.stop() darf keine Exception werfen wenn
+        process.wait() nach process.kill() erneut TimeoutExpired auslöst.
+        Ohne Fix propagiert die Exception und _reader_thread.join() wird nie erreicht."""
+        import subprocess
+        import types
+
+        client = LSPClient("Python")
+        client._running = True
+        client._reader_thread = None
+
+        process = types.SimpleNamespace(
+            terminate=lambda: None,
+            kill=lambda: None,
+            wait=unittest.mock.Mock(side_effect=subprocess.TimeoutExpired(cmd=[], timeout=3)),
+            stdin=None,
+            stdout=None,
+            stderr=None,
+        )
+        client.process = process
+
+        try:
+            client.stop()
+        except subprocess.TimeoutExpired:
+            self.fail("stop() hat TimeoutExpired propagiert — _reader_thread.join() wurde übersprungen")
+
+        self.assertIsNone(client.process)
+        self.assertIsNone(client._reader_thread)
+
+    def test_stop_joins_reader_thread_even_after_stubborn_process(self):
+        """_reader_thread.join() muss aufgerufen werden, auch wenn der Prozess
+        beim Warten auf das Ende beide Male TimeoutExpired wirft."""
+        import subprocess
+        import threading
+        import types
+
+        client = LSPClient("Python")
+        client._running = True
+
+        joined = []
+
+        class FakeThread:
+            def is_alive(self):
+                return True
+
+            def join(self, timeout=None):
+                joined.append(timeout)
+
+        client._reader_thread = FakeThread()
+
+        process = types.SimpleNamespace(
+            terminate=lambda: None,
+            kill=lambda: None,
+            wait=unittest.mock.Mock(side_effect=subprocess.TimeoutExpired(cmd=[], timeout=3)),
+            stdin=None,
+            stdout=None,
+            stderr=None,
+        )
+        client.process = process
+
+        client.stop()
+
+        self.assertTrue(joined, "_reader_thread.join() wurde nach stubborn process NICHT aufgerufen (B-009)")
+
+
 class LSPReadLoopTerminationTests(unittest.TestCase):
     def test_read_loop_terminates_on_server_death(self):
         """Regressions-Test: _read_loop darf bei Server-Tod NICHT in einer
diff --git a/tests/test_save_failure_guards.py b/tests/test_save_failure_guards.py
@@ -200,3 +200,59 @@ def test_connect_cursor_emits_no_runtime_warning_on_reconnect():
     assert hasattr(tab, "_cursor_slot"), "_cursor_slot muss nach _connect_cursor gesetzt sein"
 
     window.close()
+
+
+def test_close_event_blocks_when_user_clicks_no(tmp_path):
+    """Regression B-008: closeEvent muss QMessageBox.StandardButton verwenden.
+    Wird QMessageBox.No (deprecated, Integer) benutzt, schlägt der Vergleich
+    stumm fehl und der Dialog blockiert nie."""
+    from PySide6.QtCore import QEvent
+    _ensure_app()
+
+    with patch("features.terminal.TerminalWidget._start_shell", lambda self: None):
+        window = MainWindow()
+
+    tab = window.tab_widget.current_tab()
+    assert tab is not None
+    tab.is_modified = True
+    tab.file_path = tmp_path / "unsaved.py"
+
+    event = QEvent(QEvent.Type.Close)
+
+    with patch.object(QMessageBox, "question",
+                      return_value=QMessageBox.StandardButton.No):
+        window.closeEvent(event)
+
+    assert not event.isAccepted(), (
+        "closeEvent() muss das Schliessen blockieren, wenn der User 'No' wählt (B-008)"
+    )
+
+    tab.is_modified = False
+    window.close()
+
+
+def test_close_event_allows_when_user_clicks_yes(tmp_path):
+    """Regression B-008b: closeEvent muss Schliessen erlauben wenn User 'Yes' wählt."""
+    from PySide6.QtCore import QEvent
+    _ensure_app()
+
+    with patch("features.terminal.TerminalWidget._start_shell", lambda self: None):
+        window = MainWindow()
+
+    tab = window.tab_widget.current_tab()
+    assert tab is not None
+    tab.is_modified = True
+    tab.file_path = tmp_path / "unsaved.py"
+
+    event = QEvent(QEvent.Type.Close)
+
+    with patch.object(QMessageBox, "question",
+                      return_value=QMessageBox.StandardButton.Yes):
+        window.closeEvent(event)
+
+    assert event.isAccepted(), (
+        "closeEvent() muss Schliessen erlauben, wenn der User 'Yes' wählt (B-008b)"
+    )
+
+    tab.is_modified = False
+    window.close()
diff --git a/ui/main_window.py b/ui/main_window.py
@@ -487,9 +487,9 @@ def closeEvent(self, event):
             reply = QMessageBox.question(
                 self, "Beenden",
                 f"Es gibt ungespeicherte Änderungen in:\n{names}\n\nTrotzdem beenden?",
-                QMessageBox.Yes | QMessageBox.No
+                QMessageBox.StandardButton.Yes | QMessageBox.StandardButton.No
             )
-            if reply == QMessageBox.No:
+            if reply == QMessageBox.StandardButton.No:
                 event.ignore()
                 return
         # Terminal-Prozess sauber beenden
