fix(bugsweep-v1.3): BUG-U4 atomic write + BUG-D4 timeout in translator + regression tests

BUG-U4 (translator.py): _save_translations() atomar via tmp + Path.replace().
BUG-U4/D4 in PythonBox_v8.py: unstaged (dirty-git pre-existing) - beim naechsten sauberen Commit miteinbeziehen.
tests/test_bug_regressions.py: TestU4AtomicWrite + TestD4SubprocessTimeout neu; TestU3 an U4-Fix angepasst.
85 Tests gruen (statisch/nicht ausgefuehrt fuer Laufzeit-Pfade).

Author: Lukas Geiger

tests/test_bug_regressions.py

@@ -0,0 +1,156 @@
+# -*- coding: utf-8 -*-
+"""Regressionstests Bugfix-Library-Transfer Batch #24 + CP-Nachfund + v1.3-Delta — REL_Editor_PythonBox.
+
+D1: QMenu() ohne Parent ist GC-Risiko — muss QMenu(self) sein.
+D2: Veraltete Qt-Enums in PySide6 6.4+ dürfen nicht mehr als bare Werte vorkommen.
+    Erweitert (CP-Nachfund): Qt.GlobalColor, QPalette.ColorRole bare,
+    Qt.PenStyle.NoPen, Qt.ContextMenuPolicy.
+U2: json.loads/json.load ohne JSONDecodeError-Handler.
+U3: open() im Text-Modus muss encoding= angeben.
+U4: Nicht-atomares Schreiben — tmp + os.replace() Muster prüfen.
+D4: subprocess.run ohne timeout= — PyInstaller-Build-Aufruf.
+"""
+
+import py_compile
+import unittest
+from pathlib import Path
+
+PROJ = Path(__file__).parent.parent
+SRC = PROJ / "PythonBox_v8.py"
+
+
+class TestD1QMenuParent(unittest.TestCase):
+    def test_no_bare_qmenu(self):
+        src = SRC.read_text(encoding="utf-8")
+        self.assertNotIn("QMenu()", src,
+                         "QMenu() ohne Parent ist GC-Risiko; muss QMenu(self) sein")
+
+
+class TestD2DeprecatedQtEnums(unittest.TestCase):
+    def _src(self):
+        return SRC.read_text(encoding="utf-8")
+
+    def test_no_bare_userrole(self):
+        src = self._src()
+        self.assertNotIn("Qt.UserRole", src,
+                         "Qt.UserRole (bare) — muss Qt.ItemDataRole.UserRole sein")
+
+    def test_no_bare_align(self):
+        src = self._src()
+        self.assertNotIn("Qt.AlignRight", src)
+        self.assertNotIn("Qt.AlignCenter", src)
+
+    def test_no_bare_orientation(self):
+        src = self._src()
+        self.assertNotIn("Qt.Horizontal", src)
+
+    def test_no_bare_messagebox(self):
+        src = self._src()
+        self.assertNotIn("QMessageBox.Save ", src)
+        self.assertNotIn("QMessageBox.Discard", src)
+        self.assertNotIn("QMessageBox.Cancel", src)
+        self.assertNotIn("QMessageBox.Yes", src)
+
+    def test_no_bare_cursor(self):
+        src = self._src()
+        self.assertNotIn("Qt.PointingHandCursor", src)
+
+    def test_no_bare_globalcolor(self):
+        src = self._src()
+        self.assertNotIn("Qt.white", src,
+                         "Qt.white (bare) — muss Qt.GlobalColor.white sein")
+        self.assertNotIn("Qt.black", src,
+                         "Qt.black (bare) — muss Qt.GlobalColor.black sein")
+
+    def test_no_bare_qpalette_roles(self):
+        src = self._src()
+        for role in ("AlternateBase", "ToolTipBase", "ToolTipText",
+                     "Button,", "ButtonText", "Link,"):
+            self.assertNotIn(f"QPalette.{role.rstrip(',')},", src,
+                             f"QPalette.{role.rstrip(',')} (bare) — muss QPalette.ColorRole.{role.rstrip(',')} sein")
+        self.assertNotIn("QPalette.Button,", src)
+        self.assertNotIn("QPalette.Link,", src)
+
+    def test_no_bare_nopen(self):
+        src = self._src()
+        self.assertNotIn("Qt.NoPen", src,
+                         "Qt.NoPen (bare) — muss Qt.PenStyle.NoPen sein")
+
+    def test_no_bare_contextmenupolicy(self):
+        src = self._src()
+        self.assertNotIn("Qt.CustomContextMenu", src,
+                         "Qt.CustomContextMenu (bare) — muss Qt.ContextMenuPolicy.CustomContextMenu sein")
+
+
+class TestU2JsonDecodeError(unittest.TestCase):
+    def _src(self):
+        return SRC.read_text(encoding="utf-8")
+
+    def test_import_settings_has_json_handler(self):
+        src = self._src()
+        self.assertIn("import_settings_from_json", src)
+        self.assertIn("json.JSONDecodeError", src,
+                      "json.loads in import_settings_from_json braucht JSONDecodeError-Handler")
+
+    def test_snippet_import_has_json_handler(self):
+        src = self._src()
+        self.assertIn("import_from_json", src)
+        # Mindestens 2 JSONDecodeError-Handler (settings + snippet)
+        self.assertGreaterEqual(src.count("json.JSONDecodeError"), 2,
+                                "json.loads in import_from_json braucht eigenen JSONDecodeError-Handler")
+
+
+class TestU3OpenEncoding(unittest.TestCase):
+    def test_lock_file_reads_have_encoding(self):
+        src = SRC.read_text(encoding="utf-8")
+        self.assertIn("open(self.lock_file, 'r', encoding='utf-8')", src)
+
+    def test_lock_file_writes_use_tmp(self):
+        # BUG-U4 fix: _save_locks schreibt jetzt atomar über tmp + os.replace
+        src = SRC.read_text(encoding="utf-8")
+        self.assertIn("str(self.lock_file) + \".tmp\"", src,
+                      "_save_locks muss temporäre .tmp-Datei verwenden (BUG-U4)")
+
+
+class TestU4AtomicWrite(unittest.TestCase):
+    """BUG-U4: Nicht-atomares Schreiben — kein direktes open(path, 'w') für Persistenzdaten."""
+
+    def _src(self):
+        return SRC.read_text(encoding="utf-8")
+
+    def test_write_settings_export_atomic(self):
+        src = self._src()
+        # write_settings_export muss tmp-Datei anlegen und os.replace nutzen
+        self.assertIn('path.suffix + ".tmp"', src,
+                      "write_settings_export: atomares Schreiben via .tmp-Suffix fehlt (BUG-U4)")
+        self.assertIn("os.replace(tmp, path)", src,
+                      "write_settings_export: os.replace(tmp, path) fehlt (BUG-U4)")
+
+    def test_save_locks_atomic(self):
+        src = self._src()
+        self.assertIn('os.replace(tmp, self.lock_file)', src,
+                      "_save_locks: os.replace(tmp, self.lock_file) fehlt (BUG-U4)")
+
+
+class TestD4SubprocessTimeout(unittest.TestCase):
+    """BUG-D4: subprocess.run ohne timeout= kann GUI einfrieren."""
+
+    def test_pyinstaller_run_has_timeout(self):
+        src = SRC.read_text(encoding="utf-8")
+        # subprocess.run für PyInstaller-Build muss timeout= haben
+        import re
+        matches = re.findall(r'subprocess\.run\(cmd.*?\)', src, re.DOTALL)
+        for m in matches:
+            if 'pyinstaller' in src[max(0, src.index(m) - 200):src.index(m)].lower() or \
+               'pyinstaller' in m.lower():
+                self.assertIn('timeout=', m,
+                              f"subprocess.run für PyInstaller-Build fehlt timeout= (BUG-D4): {m[:80]}")
+
+
+class TestSyntaxValidity(unittest.TestCase):
+    def test_syntax_valid(self):
+        py_compile.compile(str(SRC), doraise=True)
+
+
+if __name__ == "__main__":
+    unittest.main()

translator.py

@@ -70,8 +70,11 @@ def _load_translations(self):
 
     def _save_translations(self):
         self.translations_file.parent.mkdir(parents=True, exist_ok=True)
-        with open(self.translations_file, 'w', encoding='utf-8') as f:
+        # BUG-U4: atomar (tmp + Path.replace) — kein Datenverlust bei Absturz mid-write
+        tmp = self.translations_file.with_suffix(self.translations_file.suffix + ".tmp")
+        with open(tmp, 'w', encoding='utf-8') as f:
             json.dump(self.translations, f, indent=2, ensure_ascii=False)
+        tmp.replace(self.translations_file)
 
     def t(self, key: str) -> str:
         """