Standardisation 6

tests/test_gui_core.py

@@ -306,6 +306,10 @@ class StandardCliTests(unittest.TestCase):
             "splitting_int": load_script_module(
                 "splitting_int.py", "splitting_int"
             ),
+            "page_splitter": load_script_module(
+                "page_splitter.py", "page_splitter"
+            ),
+            "plotting": load_script_module("plotting.py", "plotting"),
             "copies_tools": load_script_module(
                 "copies_tools.py", "copienator_copies_tools_test"
             ),
@@ -345,6 +349,8 @@ class StandardCliTests(unittest.TestCase):
                 "reading_grouped_annotations": [missing],
                 "cutleft": [missing],
                 "splitting_int": [missing],
+                "page_splitter": [missing],
+                "plotting": [missing],
             }
             for name, arguments in invocations.items():
                 with self.subTest(script=name), redirect_stderr(io.StringIO()):
@@ -447,6 +453,16 @@ class StandardCliTests(unittest.TestCase):
                 "default",
                 {"target": evaluation},
             ),
+            "page_splitter": (
+                "page_splitter",
+                "default",
+                {"target": evaluation},
+            ),
+            "plotting": (
+                "plotting",
+                "default",
+                {"target": evaluation},
+            ),
         }
         for module_name, (step_id, variant_id, values) in cases.items():
             step = steps[step_id]
@@ -654,6 +670,109 @@ class StandardCliTests(unittest.TestCase):
             self.assertTrue(answer.is_file())
             self.assertEqual(len(PdfReader(answer).pages), 1)
 
+    def test_page_splitter_commits_original_and_generated_copy(self) -> None:
+        module = self.modules["page_splitter"]
+        with tempfile.TemporaryDirectory() as directory:
+            evaluation = Path(directory) / "Exam"
+            evaluation.mkdir()
+            original = evaluation / "Copie01.pdf"
+            generated = evaluation / ".generated.pdf"
+            original.write_bytes(b"original")
+            generated.write_bytes(b"processed")
+            workspace = EvaluationWorkspace(evaluation)
+
+            output = module.commit_processed_pdf(workspace, original, generated)
+            self.assertEqual(output, evaluation / "Copies" / "Copie01.pdf")
+            self.assertEqual(output.read_bytes(), b"processed")
+            self.assertEqual(
+                (evaluation / "Copies Originales" / "Copie01.pdf").read_bytes(),
+                b"original",
+            )
+            self.assertFalse(original.exists())
+
+    def test_page_splitter_commit_failure_rolls_back_both_files(self) -> None:
+        module = self.modules["page_splitter"]
+        with tempfile.TemporaryDirectory() as directory:
+            evaluation = Path(directory) / "Exam"
+            original = evaluation / "Copie01.pdf"
+            backup = evaluation / "Copies Originales" / "Copie01.pdf"
+            output = evaluation / "Copies" / "Copie01.pdf"
+            backup.parent.mkdir(parents=True)
+            output.parent.mkdir()
+            original.write_bytes(b"new original")
+            backup.write_bytes(b"previous original")
+            output.write_bytes(b"previous output")
+            missing_generated = evaluation / "missing-generated.pdf"
+
+            with self.assertRaises(FileNotFoundError):
+                module.commit_processed_pdf(
+                    EvaluationWorkspace(evaluation), original, missing_generated
+                )
+            self.assertEqual(original.read_bytes(), b"new original")
+            self.assertEqual(backup.read_bytes(), b"previous original")
+            self.assertEqual(output.read_bytes(), b"previous output")
+
+    def test_page_splitter_reprocesses_from_preserved_original(self) -> None:
+        module = self.modules["page_splitter"]
+        with tempfile.TemporaryDirectory() as directory:
+            evaluation = Path(directory) / "Exam"
+            generated = evaluation / "Copies" / "Copie01.pdf"
+            original = evaluation / "Copies Originales" / "Copie01.pdf"
+            generated.parent.mkdir(parents=True)
+            original.parent.mkdir()
+            generated.write_bytes(b"processed")
+            original.write_bytes(b"original")
+            workspace = EvaluationWorkspace(evaluation)
+            self.assertEqual(
+                module._selected_inputs(workspace, generated),
+                [original],
+            )
+
+    def test_plotting_batch_save_is_atomic(self) -> None:
+        module = self.modules["plotting"]
+        with tempfile.TemporaryDirectory() as directory:
+            evaluation = Path(directory) / "Exam"
+            (evaluation / "Copies").mkdir(parents=True)
+            viewer = module.ImageViewer.__new__(module.ImageViewer)
+            viewer.base_dir = evaluation
+            viewer.active_copie_name = "Copie01"
+            viewer.accumulated_results = {
+                "name": "Test",
+                "list": [{"label": "Ex 1"}],
+            }
+            viewer.save_current_batch()
+            self.assertEqual(
+                read_json(evaluation / "Copies" / "Copie01.json"),
+                {"name": "Test", "list": [{"label": "Ex 1"}]},
+            )
+            self.assertIsNone(viewer.accumulated_results)
+
+    def test_plotting_validates_plain_and_directional_labels(self) -> None:
+        module = self.modules["plotting"]
+        self.assertEqual(
+            module.normalized_labels(
+                [
+                    {"label": "Ex 1"},
+                    {"label": "|Ex 2"},
+                    {"label": "Ex 3|"},
+                    {"label": "_"},
+                ]
+            ),
+            ["Ex 1", "Ex 2", "Ex 3"],
+        )
+
+    def test_plotting_worker_failure_still_terminates_its_queue(self) -> None:
+        module = self.modules["plotting"]
+        output_queue = queue.Queue()
+        with patch.object(
+            module, "_worker_items", side_effect=RuntimeError("worker failed")
+        ):
+            module.worker_thread(Path("."), [], [], output_queue)
+        image, json_path, metadata = output_queue.get_nowait()
+        self.assertIsNone(image)
+        self.assertIsNone(json_path)
+        self.assertEqual(metadata, {"worker_error": "worker failed"})
+
     def test_post_correction_main_cleans_json_atomically(self) -> None:
         module = self.modules["post_correction"]
         with tempfile.TemporaryDirectory() as directory: