Add unit tests for ref-utils

Test coverage for:
- assertion.py: file/dir existence checks
- checks.py: pylint, mypy, flag checking
- config.py: configuration and override_config context manager
- decorator.py: test registration and run_tests()
- error.py: custom exception types
- process.py: privilege dropping and subprocess execution
- serialization.py: JSON-based IPC serialization
- utils.py: colored printing and environment handling

Includes security tests verifying JSON serializer is safe against
pickle-based exploits (DoS, attribute injection, etc).

Author: Nils Bars

tests/__init__.py

@@ -0,0 +1 @@
+"""Tests for ref-utils library."""

tests/conftest.py

@@ -0,0 +1,74 @@
+"""Pytest configuration and fixtures for ref-utils tests."""
+import sys
+from pathlib import Path
+from typing import Generator
+from unittest.mock import patch
+
+import pytest
+
+from ref_utils.config import Config, override_config
+
+
+@pytest.fixture
+def test_config(tmp_path: Path) -> Config:
+    """Provide a Config with all paths pointing to tmp_path."""
+    return Config(
+        user_environ_path=tmp_path / ".user_environ",
+        pylint_config_path=tmp_path / "pylintrc",
+        mypy_config_path=tmp_path / "mypyrc",
+        user_home_path=tmp_path / "home",
+        drop_uid=9999,
+        drop_gid=9999,
+    )
+
+
+@pytest.fixture
+def use_test_config(test_config: Config) -> Generator[Config, None, None]:
+    """Context fixture that overrides config for the test."""
+    with override_config(test_config):
+        yield test_config
+
+
+@pytest.fixture
+def user_environ_file(test_config: Config) -> Path:
+    """Create a mock user environment file with sample data."""
+    content = "HOME=/home/user\x00USER=testuser\x00PATH=/usr/bin\x00"
+    test_config.user_environ_path.write_text(content)
+    return test_config.user_environ_path
+
+
+@pytest.fixture
+def disable_exception_hook() -> Generator[None, None, None]:
+    """Disable the global exception hook installed by ref_utils during tests."""
+    original_hook = sys.excepthook
+    yield
+    sys.excepthook = original_hook
+
+
+@pytest.fixture
+def reset_registered_tasks() -> Generator[None, None, None]:
+    """Reset the global __registered_tasks dict between tests."""
+    # Import the module to access its internal state
+    from ref_utils import decorator
+
+    original_tasks = decorator.__registered_tasks.copy()
+    decorator.__registered_tasks.clear()
+    yield
+    decorator.__registered_tasks.clear()
+    decorator.__registered_tasks.update(original_tasks)
+
+
+@pytest.fixture
+def mock_subprocess_run():
+    """Mock subprocess.run for testing process functions."""
+    with patch("subprocess.run") as mock_run:
+        yield mock_run
+
+
+@pytest.fixture
+def mock_multiprocessing():
+    """Mock multiprocessing.Process and Pipe for testing privilege dropping."""
+    with patch("ref_utils.process.Process") as mock_process, patch(
+        "ref_utils.process.Pipe"
+    ) as mock_pipe:
+        yield mock_process, mock_pipe

tests/test_assertion.py

@@ -0,0 +1,169 @@
+"""Tests for ref_utils.assertion module."""
+from io import StringIO
+from pathlib import Path
+from unittest.mock import patch
+
+from ref_utils.assertion import _assert, assert_is_dir, assert_is_exec, assert_is_file
+
+
+class TestAssert:
+    """Tests for the _assert helper function."""
+
+    def test_assert_true_condition(self) -> None:
+        """Test that _assert returns True for true conditions."""
+        assert _assert(True, "error message", silent=False) is True
+
+    def test_assert_false_condition_silent(self) -> None:
+        """Test that _assert returns False silently when silent=True."""
+        with patch("sys.stdout", new_callable=StringIO) as mock_stdout:
+            result = _assert(False, "error message", silent=True)
+            assert result is False
+            # Should not print anything in silent mode
+            assert mock_stdout.getvalue() == ""
+
+    def test_assert_false_condition_prints_error(self) -> None:
+        """Test that _assert prints error message when silent=False."""
+        with patch("ref_utils.assertion.print_err") as mock_print_err:
+            result = _assert(False, "test error", silent=False)
+            assert result is False
+            mock_print_err.assert_called_once()
+            call_args = mock_print_err.call_args[0][0]
+            assert "test error" in call_args
+
+
+class TestAssertIsExec:
+    """Tests for assert_is_exec function."""
+
+    def test_existing_executable(self, tmp_path: Path) -> None:
+        """Test with an existing executable file."""
+        exec_file = tmp_path / "test_exec"
+        exec_file.write_text("#!/bin/bash\necho hello")
+        exec_file.chmod(0o755)
+
+        assert assert_is_exec(exec_file) is True
+
+    def test_existing_executable_as_string(self, tmp_path: Path) -> None:
+        """Test with path provided as string."""
+        exec_file = tmp_path / "test_exec"
+        exec_file.write_text("#!/bin/bash\necho hello")
+        exec_file.chmod(0o755)
+
+        assert assert_is_exec(str(exec_file)) is True
+
+    def test_non_existing_file(self, tmp_path: Path) -> None:
+        """Test with a non-existing file."""
+        non_existing = tmp_path / "does_not_exist"
+
+        with patch("ref_utils.assertion.print_err"):
+            assert assert_is_exec(non_existing) is False
+
+    def test_non_executable_file(self, tmp_path: Path) -> None:
+        """Test with an existing but non-executable file."""
+        non_exec = tmp_path / "not_exec"
+        non_exec.write_text("some content")
+        non_exec.chmod(0o644)
+
+        with patch("ref_utils.assertion.print_err"):
+            assert assert_is_exec(non_exec) is False
+
+    def test_directory_not_executable(self, tmp_path: Path) -> None:
+        """Test that a directory is not considered an executable."""
+        test_dir = tmp_path / "test_dir"
+        test_dir.mkdir()
+
+        with patch("ref_utils.assertion.print_err"):
+            assert assert_is_exec(test_dir) is False
+
+    def test_silent_mode(self, tmp_path: Path) -> None:
+        """Test silent mode doesn't print errors."""
+        non_existing = tmp_path / "does_not_exist"
+
+        with patch("ref_utils.assertion.print_err") as mock_print:
+            assert assert_is_exec(non_existing, silent=True) is False
+            mock_print.assert_not_called()
+
+
+class TestAssertIsFile:
+    """Tests for assert_is_file function."""
+
+    def test_existing_file(self, tmp_path: Path) -> None:
+        """Test with an existing file."""
+        test_file = tmp_path / "test_file.txt"
+        test_file.write_text("content")
+
+        assert assert_is_file(test_file) is True
+
+    def test_existing_file_as_string(self, tmp_path: Path) -> None:
+        """Test with path provided as string."""
+        test_file = tmp_path / "test_file.txt"
+        test_file.write_text("content")
+
+        assert assert_is_file(str(test_file)) is True
+
+    def test_non_existing_file(self, tmp_path: Path) -> None:
+        """Test with a non-existing file."""
+        non_existing = tmp_path / "does_not_exist"
+
+        with patch("ref_utils.assertion.print_err"):
+            assert assert_is_file(non_existing) is False
+
+    def test_directory_is_not_file(self, tmp_path: Path) -> None:
+        """Test that a directory is not considered a file."""
+        test_dir = tmp_path / "test_dir"
+        test_dir.mkdir()
+
+        with patch("ref_utils.assertion.print_err"):
+            assert assert_is_file(test_dir) is False
+
+    def test_silent_mode(self, tmp_path: Path) -> None:
+        """Test silent mode doesn't print errors."""
+        non_existing = tmp_path / "does_not_exist"
+
+        with patch("ref_utils.assertion.print_err") as mock_print:
+            assert assert_is_file(non_existing, silent=True) is False
+            mock_print.assert_not_called()
+
+
+class TestAssertIsDir:
+    """Tests for assert_is_dir function."""
+
+    def test_existing_directory(self, tmp_path: Path) -> None:
+        """Test with an existing directory."""
+        test_dir = tmp_path / "test_dir"
+        test_dir.mkdir()
+
+        assert assert_is_dir(test_dir) is True
+
+    def test_existing_directory_as_string(self, tmp_path: Path) -> None:
+        """Test with path provided as string."""
+        test_dir = tmp_path / "test_dir"
+        test_dir.mkdir()
+
+        assert assert_is_dir(str(test_dir)) is True
+
+    def test_non_existing_directory(self, tmp_path: Path) -> None:
+        """Test with a non-existing directory."""
+        non_existing = tmp_path / "does_not_exist"
+
+        with patch("ref_utils.assertion.print_err"):
+            assert assert_is_dir(non_existing) is False
+
+    def test_file_is_not_directory(self, tmp_path: Path) -> None:
+        """Test that a file is not considered a directory."""
+        test_file = tmp_path / "test_file.txt"
+        test_file.write_text("content")
+
+        with patch("ref_utils.assertion.print_err"):
+            assert assert_is_dir(test_file) is False
+
+    def test_silent_mode(self, tmp_path: Path) -> None:
+        """Test silent mode doesn't print errors."""
+        non_existing = tmp_path / "does_not_exist"
+
+        with patch("ref_utils.assertion.print_err") as mock_print:
+            assert assert_is_dir(non_existing, silent=True) is False
+            mock_print.assert_not_called()
+
+    def test_tmp_path_is_directory(self, tmp_path: Path) -> None:
+        """Test that tmp_path fixture itself is a directory."""
+        assert assert_is_dir(tmp_path) is True