Merge branch 'testing'

Author: chrisdpurcell

docs/plans/2026-02-21-qt-implementation-fixes.md

@@ -32,7 +32,7 @@ def create_application() -> MainWindow:
     return MainWindow(viewmodel)
 
 
-def main() -> None:
+def main() -> None:  # pragma: no cover
     """Application entry point."""
     logger.info("Starting TextTools")
     app = QApplication(sys.argv)
@@ -46,5 +46,5 @@ def main() -> None:
     sys.exit(app.exec())
 
 
-if __name__ == "__main__":
+if __name__ == "__main__":  # pragma: no cover
     main()

docs/plans/2026-02-21-test-coverage-plan.md

@@ -4,6 +4,8 @@
 
 import pytest
 
+from src.utils.constants import APP_VERSION
+
 from src.models.cleaning_options import CleaningOptions
 from src.models.text_document import TextDocument
 from src.viewmodels.main_viewmodel import MainViewModel
@@ -108,3 +110,228 @@ def test_merge_tab_has_coming_soon_label(self, window):
         label = window.ui.findChild(QLabel, "mergeComingSoonLabel")
         assert label is not None
         assert "coming soon" in label.text().lower()
+
+
+class TestRequireHelper:
+    def test_raises_for_none_widget(self):
+        from src.views.main_window import _require
+
+        with pytest.raises(RuntimeError, match="Required widget 'myWidget'"):
+            _require(None, "myWidget")
+
+    def test_returns_widget_when_present(self):
+        from src.views.main_window import _require
+
+        sentinel = object()
+        assert _require(sentinel, "any") is sentinel
+
+
+class TestWindowShow:
+    def test_show_does_not_raise(self, window):
+        # Covers MainWindow.show() — line 81
+        window.show()
+
+
+class TestLoadUiErrors:
+    def test_raises_if_ui_file_unreadable(self, monkeypatch, qapp):
+        from unittest.mock import MagicMock
+        from src.views.main_window import MainWindow
+
+        monkeypatch.setattr(
+            "src.views.main_window.QFile.open", lambda *_: False
+        )
+        with pytest.raises(RuntimeError, match="Cannot open UI file"):
+            MainWindow(MagicMock())
+
+    def test_raises_if_loader_returns_none(self, monkeypatch, qapp):
+        from unittest.mock import MagicMock
+        from src.views.main_window import MainWindow
+
+        monkeypatch.setattr(
+            "src.views.main_window.QUiLoader.load", lambda *_: None
+        )
+        with pytest.raises(RuntimeError, match="QUiLoader failed"):
+            MainWindow(MagicMock())
+
+
+class TestSaveHandler:
+    def test_warning_shown_when_filepath_empty(self, window, monkeypatch):
+        """Empty fileNameEdit triggers QMessageBox.warning — lines 240-244."""
+        warnings: list = []
+        monkeypatch.setattr(
+            "src.views.main_window.QMessageBox.warning",
+            lambda *a: warnings.append(a),
+        )
+        window._file_name_edit.setText("")
+        window._on_save_clicked()
+        assert len(warnings) == 1
+
+    def test_save_delegates_to_viewmodel(self, window, qtbot):
+        """Non-empty filepath triggers ViewModel.save_file — line 246."""
+        window._file_name_edit.setText("/tmp/out.txt")
+        window._plain_text_edit.setPlainText("some content")
+        with qtbot.waitSignal(window._viewmodel.file_saved, timeout=1000):
+            window._on_save_clicked()
+
+
+class TestCleanHandler:
+    def test_checking_trim_checkbox_triggers_cleaning(
+        self, window, mock_text_svc, qtbot
+    ):
+        """stateChanged → _on_clean_requested — lines 253-258."""
+        window._viewmodel.load_file("/tmp/test.txt")
+        qtbot.wait(10)
+        with qtbot.waitSignal(window._viewmodel.content_updated, timeout=1000):
+            window._trim_cb.setChecked(True)
+
+    def test_clean_options_reflect_checkbox_states(
+        self, window, mock_text_svc, qtbot
+    ):
+        window._viewmodel.load_file("/tmp/test.txt")
+        qtbot.wait(10)
+        window._clean_cb.setChecked(False)
+        window._remove_tabs_cb.setChecked(True)
+        window._on_clean_requested()
+        call_args = mock_text_svc.apply_options.call_args
+        opts = call_args[0][1]
+        assert opts.remove_tabs is True
+        assert opts.clean_whitespace is False
+
+
+class TestFindHandler:
+    def test_empty_term_is_no_op(self, window):
+        """Empty findLineEdit → early return at line 264."""
+        window._find_edit.setText("")
+        window._on_find_clicked()  # should not raise or select anything
+        assert not window._plain_text_edit.textCursor().hasSelection()
+
+    def test_finds_existing_text(self, window, qtbot):
+        """find() succeeds — line 265 (found=True branch)."""
+        window._viewmodel.load_file("/tmp/test.txt")
+        qtbot.wait(10)
+        window._plain_text_edit.setPlainText("hello world")
+        window._find_edit.setText("hello")
+        window._on_find_clicked()
+        assert window._plain_text_edit.textCursor().hasSelection()
+
+    def test_wraps_when_not_found_from_end(self, window):
+        """find() returns False → cursor wraps to start — lines 267-271."""
+        window._plain_text_edit.setPlainText("hello")
+        # Move cursor to end so the first find('hello') misses
+        cursor = window._plain_text_edit.textCursor()
+        cursor.movePosition(cursor.MoveOperation.End)
+        window._plain_text_edit.setTextCursor(cursor)
+        window._find_edit.setText("hello")
+        window._on_find_clicked()  # wraps and finds from start
+        assert window._plain_text_edit.textCursor().hasSelection()
+
+
+class TestReplaceHandler:
+    def test_empty_find_term_is_no_op(self, window):
+        """Empty findLineEdit → early return at line 278."""
+        window._find_edit.setText("")
+        window._on_replace_clicked()  # should not raise
+
+    def test_replace_with_no_selection_calls_find(self, window):
+        """No selection → skips replacement, falls through to find — lines 279-282."""
+        window._plain_text_edit.setPlainText("hello world")
+        window._find_edit.setText("hello")
+        window._replace_edit.setText("goodbye")
+        window._on_replace_clicked()
+        # find() advances cursor to 'hello' after replace falls through
+        assert window._plain_text_edit.textCursor().hasSelection()
+
+    def test_replace_matching_selection_inserts_replacement(self, window):
+        """Matching selection → text replaced — line 281."""
+        window._plain_text_edit.setPlainText("hello world")
+        window._find_edit.setText("hello")
+        window._replace_edit.setText("goodbye")
+        # Manually select 'hello'
+        cursor = window._plain_text_edit.textCursor()
+        cursor.setPosition(0)
+        cursor.setPosition(5, cursor.MoveMode.KeepAnchor)
+        window._plain_text_edit.setTextCursor(cursor)
+        window._on_replace_clicked()
+        assert "goodbye" in window._plain_text_edit.toPlainText()
+
+
+class TestReplaceAllHandler:
+    def test_replace_all_emits_content_updated(self, window, qtbot):
+        """_on_replace_all_clicked delegates to ViewModel — line 289."""
+        window._viewmodel.load_file("/tmp/test.txt")
+        qtbot.wait(10)
+        window._find_edit.setText("hello")
+        window._replace_edit.setText("goodbye")
+        with qtbot.waitSignal(window._viewmodel.content_updated, timeout=1000):
+            window._on_replace_all_clicked()
+
+
+class TestTreeClickHandler:
+    def test_file_click_loads_file(self, window, tmp_path, qtbot):
+        """Clicking a file path sets fileNameEdit and calls load_file — lines 233-234."""
+        f = tmp_path / "click.txt"
+        f.write_text("click content", encoding="utf-8")
+        window._fs_model.filePath = MagicMock(return_value=str(f))
+        with qtbot.waitSignal(window._viewmodel.document_loaded, timeout=1000):
+            window._on_tree_item_clicked(MagicMock())
+        assert window._file_name_edit.text() == str(f)  # confirms line 233 ran
+
+    def test_directory_click_is_ignored(self, window, tmp_path):
+        """Clicking a directory does not call load_file — line 232 branch."""
+        window._fs_model.filePath = MagicMock(return_value=str(tmp_path))
+        emitted: list = []
+        window._viewmodel.document_loaded.connect(emitted.append)
+        window._on_tree_item_clicked(MagicMock())
+        assert emitted == []
+
+
+class TestActionOpenHandler:
+    def test_chosen_file_is_loaded(self, window, tmp_path, monkeypatch, qtbot):
+        """QFileDialog returns path → file loaded — lines 304-306."""
+        f = tmp_path / "opened.txt"
+        f.write_text("opened", encoding="utf-8")
+        monkeypatch.setattr(
+            "src.views.main_window.QFileDialog.getOpenFileName",
+            lambda *a, **kw: (str(f), ""),
+        )
+        with qtbot.waitSignal(window._viewmodel.document_loaded, timeout=1000):
+            window._on_action_open()
+        assert window._file_name_edit.text() == str(f)  # confirms line 305 ran
+
+    def test_cancelled_dialog_is_no_op(self, window, monkeypatch):
+        """QFileDialog returns '' → nothing happens — lines 303-304 branch."""
+        monkeypatch.setattr(
+            "src.views.main_window.QFileDialog.getOpenFileName",
+            lambda *a, **kw: ("", ""),
+        )
+        emitted: list = []
+        window._viewmodel.document_loaded.connect(emitted.append)
+        window._on_action_open()
+        assert emitted == []
+
+
+class TestActionAboutHandler:
+    def test_about_dialog_is_shown(self, window, monkeypatch):
+        """actionAbout → QMessageBox.about called — line 310."""
+        calls: list = []
+        monkeypatch.setattr(
+            "src.views.main_window.QMessageBox.about",
+            lambda *a: calls.append(a),
+        )
+        window._on_action_about()
+        assert len(calls) == 1
+        assert APP_VERSION in calls[0][2]
+
+
+class TestErrorHandler:
+    def test_error_signal_shows_critical_dialog(self, window, monkeypatch, qtbot):
+        """error_occurred signal → QMessageBox.critical — line 366."""
+        calls: list = []
+        monkeypatch.setattr(
+            "src.views.main_window.QMessageBox.critical",
+            lambda *a, **kw: calls.append(a),
+        )
+        window._viewmodel.error_occurred.emit("something went wrong")
+        qtbot.wait(10)
+        assert len(calls) == 1
+        assert "something went wrong" in calls[0][2]

docs/plans/2026-02-21-test-coverage.md

@@ -68,3 +68,49 @@ def test_overwrites_existing_file(self, svc, tmp_path):
         doc = TextDocument(filepath=str(f), content="new content")
         svc.save_file(doc)
         assert f.read_text(encoding="utf-8") == "new content"
+
+
+class TestDetectEncoding:
+    """Tests for _detect_encoding — module-level function in file_service.py."""
+
+    def test_utf16_le_detected_by_chardet(self):
+        """UTF-16 with BOM gives chardet confidence=1.0, exercising the chardet branch.
+
+        Using encode('utf-16') emits a BOM so chardet reliably returns 'UTF-16'.
+        Raw UTF-16-LE without BOM requires long content for chardet to reach the
+        0.7 confidence threshold, making it fragile for short test strings.
+        """
+        pytest.importorskip("chardet")  # skip gracefully if chardet not installed
+        from src.services.file_service import _detect_encoding
+
+        # encode('utf-16') prepends a BOM; chardet returns 'UTF-16' with confidence=1.0
+        raw = "hello world".encode("utf-16")
+        encoding = _detect_encoding(raw)
+        # chardet returns 'UTF-16' (with BOM) or 'utf-16le'/'utf-16-le' (without BOM)
+        assert encoding.lower() in ("utf-16", "utf-16le", "utf-16-le")
+
+    def test_falls_back_to_utf8_for_undetectable_bytes(self):
+        """Empty bytes: chardet returns None encoding → fallback to utf-8."""
+        from src.services.file_service import _detect_encoding
+
+        encoding = _detect_encoding(b"")
+        assert encoding == "utf-8"
+
+
+class TestAtomicSaveCleanup:
+    """Verify temp file is cleaned up when os.replace fails (lines 70-75)."""
+
+    def test_temp_file_removed_on_replace_failure(self, svc, tmp_path, monkeypatch):
+        removed: list[str] = []
+
+        def _failing_replace(src: str, dst: str) -> None:
+            raise OSError("simulated disk full")
+
+        monkeypatch.setattr("src.services.file_service.os.replace", _failing_replace)
+        monkeypatch.setattr("src.services.file_service.os.unlink", lambda p: removed.append(p))
+
+        doc = TextDocument(filepath=str(tmp_path / "out.txt"), content="data")
+        with pytest.raises(OSError, match="simulated disk full"):
+            svc.save_file(doc)
+
+        assert len(removed) == 1, "temp file should have been unlinked on failure"

src/main.py

@@ -0,0 +1,27 @@
+"""Unit tests for src/main.py — composition root."""
+
+import pytest
+
+import src.main as main_module
+from src.main import create_application
+from src.views.main_window import MainWindow
+
+
+@pytest.fixture()
+def window(qapp):
+    w = create_application()
+    yield w
+    w.ui.close()
+
+
+class TestModuleImport:
+    def test_module_has_logger(self):
+        assert main_module.logger is not None
+
+
+class TestCreateApplication:
+    def test_returns_main_window(self, window):
+        assert isinstance(window, MainWindow)
+
+    def test_window_has_viewmodel(self, window):
+        assert window._viewmodel is not None