Improve coverage for external and utils modules (#1432)

Co-authored-by: Copilot <223556219+Copilot@users.noreply.github.com>

Author: fepegar

tests/external/__init__.py

@@ -0,0 +1,36 @@
+"""Tests for external.due module (duecredit stub)."""
+
+from torchio.external.due import InactiveDueCreditCollector
+
+
+class TestInactiveDueCreditCollector:
+    """Tests for the duecredit stub collector."""
+
+    def test_dcite_returns_identity_decorator(self):
+        """dcite() returns a decorator that does not modify the function."""
+        collector = InactiveDueCreditCollector()
+
+        @collector.dcite(description='test')
+        def my_function():
+            return 42
+
+        assert my_function() == 42
+
+    def test_repr(self):
+        """__repr__ returns class name with parens."""
+        collector = InactiveDueCreditCollector()
+        assert repr(collector) == 'InactiveDueCreditCollector()'
+
+    def test_active_is_false(self):
+        """Stub collector is not active."""
+        collector = InactiveDueCreditCollector()
+        assert collector.active is False
+
+    def test_donothing_methods(self):
+        """activate, add, cite, dump, load are all no-ops."""
+        collector = InactiveDueCreditCollector()
+        collector.activate()
+        collector.add()
+        collector.cite()
+        collector.dump()
+        collector.load()

tests/external/test_due.py

@@ -0,0 +1,80 @@
+"""Tests for external.imports module."""
+
+from unittest.mock import patch
+
+import pytest
+
+from torchio.external.imports import _check_executable
+from torchio.external.imports import _check_module
+
+
+class TestCheckModule:
+    """Tests for _check_module function."""
+
+    def test_missing_module_raises_import_error(self):
+        """_check_module raises ImportError when module is not found."""
+        with pytest.raises(ImportError, match='torchio_nonexistent_pkg'):
+            _check_module(
+                module='torchio_nonexistent_pkg',
+                extra='test',
+            )
+
+    def test_missing_module_uses_package_name(self):
+        """ImportError message uses package name when provided."""
+        with pytest.raises(ImportError, match='my-custom-package'):
+            _check_module(
+                module='torchio_nonexistent_pkg',
+                extra='test',
+                package='my-custom-package',
+            )
+
+    def test_existing_module_passes(self):
+        """_check_module does not raise for installed modules."""
+        _check_module(module='torch', extra='test')
+
+
+class TestCheckExecutable:
+    """Tests for _check_executable function."""
+
+    def test_missing_executable_raises(self):
+        """Missing executable raises FileNotFoundError."""
+        with pytest.raises(FileNotFoundError, match='nonexistent_binary_xyz'):
+            _check_executable('nonexistent_binary_xyz')
+
+    def test_existing_executable_passes(self):
+        """Existing executable does not raise."""
+        _check_executable('python3')
+
+    def test_which_returns_none(self):
+        """FileNotFoundError raised when which() returns None."""
+        with patch('torchio.external.imports.which', return_value=None):
+            with pytest.raises(FileNotFoundError, match='ffmpeg'):
+                _check_executable('ffmpeg')
+
+
+class TestGetHelpers:
+    """Tests for get_* import helpers."""
+
+    def test_get_pandas_missing(self):
+        """get_pandas raises ImportError when pandas not installed."""
+        from torchio.external.imports import get_pandas
+
+        with patch('torchio.external.imports.find_spec', return_value=None):
+            with pytest.raises(ImportError, match='pandas'):
+                get_pandas()
+
+    def test_get_colorcet_missing(self):
+        """get_colorcet raises ImportError when not installed."""
+        from torchio.external.imports import get_colorcet
+
+        with patch('torchio.external.imports.find_spec', return_value=None):
+            with pytest.raises(ImportError, match='colorcet'):
+                get_colorcet()
+
+    def test_get_ffmpeg_missing_module(self):
+        """get_ffmpeg raises ImportError when ffmpeg module not found."""
+        from torchio.external.imports import get_ffmpeg
+
+        with patch('torchio.external.imports.find_spec', return_value=None):
+            with pytest.raises(ImportError, match='ffmpeg-python'):
+                get_ffmpeg()

tests/external/test_imports.py

@@ -1,4 +1,8 @@
 import copy
+import os
+import tempfile
+from pathlib import Path
+from unittest.mock import patch
 
 import pytest
 import torch
@@ -85,3 +89,139 @@ def test_add_images_from_batch(self):
     def test_empty_batch(self):
         with pytest.raises(RuntimeError):
             tio.utils.get_batch_images_and_size({})
+
+    def test_compress_default_output(self):
+        """compress() creates .nii.gz from input with default output."""
+        with tempfile.TemporaryDirectory() as tmp:
+            input_path = Path(tmp) / 'test.nii'
+            input_path.write_bytes(b'fake nifti data')
+            result = tio.utils.compress(input_path)
+            assert result.exists()
+            assert result.suffix == '.gz'
+
+    def test_compress_explicit_output(self):
+        """compress() writes to the specified output path."""
+        with tempfile.TemporaryDirectory() as tmp:
+            input_path = Path(tmp) / 'test.nii'
+            input_path.write_bytes(b'fake nifti data')
+            output_path = Path(tmp) / 'compressed.nii.gz'
+            result = tio.utils.compress(input_path, output_path)
+            assert result == output_path
+            assert result.exists()
+
+    def test_history_collate_non_subject(self):
+        """history_collate returns empty dict for non-Subject batches."""
+        result = tio.utils.history_collate([{'a': 1}])
+        assert result == {}
+
+    def test_create_dummy_dataset_force(self):
+        """create_dummy_dataset with force=True recreates directories."""
+        with tempfile.TemporaryDirectory() as tmp:
+            subjects = tio.utils.create_dummy_dataset(
+                num_images=2,
+                size_range=(5, 10),
+                directory=tmp,
+            )
+            assert len(subjects) == 2
+            # Call again with force to recreate
+            subjects = tio.utils.create_dummy_dataset(
+                num_images=2,
+                size_range=(5, 10),
+                directory=tmp,
+                force=True,
+            )
+            assert len(subjects) == 2
+
+    def test_create_dummy_dataset_existing(self):
+        """create_dummy_dataset loads from existing dirs without force."""
+        with tempfile.TemporaryDirectory() as tmp:
+            tio.utils.create_dummy_dataset(
+                num_images=2,
+                size_range=(5, 10),
+                directory=tmp,
+            )
+            # Call again without force — loads from existing paths
+            subjects = tio.utils.create_dummy_dataset(
+                num_images=2,
+                size_range=(5, 10),
+                directory=tmp,
+            )
+            assert len(subjects) == 2
+
+    def test_create_dummy_dataset_verbose(self):
+        """create_dummy_dataset with verbose=True prints a message."""
+        with tempfile.TemporaryDirectory() as tmp:
+            subjects = tio.utils.create_dummy_dataset(
+                num_images=1,
+                size_range=(5, 10),
+                directory=tmp,
+                verbose=True,
+            )
+            assert len(subjects) == 1
+
+    def test_parse_spatial_shape_wrong_length(self):
+        """parse_spatial_shape raises ValueError for non-3-element shapes."""
+        with pytest.raises(ValueError, match='3 elements'):
+            tio.utils.parse_spatial_shape((10, 20))
+
+    def test_normalize_path(self):
+        """normalize_path expands ~ and resolves to absolute path."""
+        result = tio.utils.normalize_path('~/test')
+        assert result.is_absolute()
+        assert '~' not in str(result)
+
+    def test_guess_external_viewer_env_var(self):
+        """guess_external_viewer returns SITK_SHOW_COMMAND if set."""
+        with patch.dict(os.environ, {'SITK_SHOW_COMMAND': '/usr/bin/viewer'}):
+            result = tio.utils.guess_external_viewer()
+            assert result == Path('/usr/bin/viewer')
+
+    def test_guess_external_viewer_linux_itksnap(self):
+        """guess_external_viewer finds itksnap on Linux."""
+        with (
+            patch('torchio.utils.sys') as mock_sys,
+            patch('torchio.utils.shutil') as mock_shutil,
+            patch.dict(os.environ, {}, clear=False),
+        ):
+            # Remove SITK_SHOW_COMMAND if present
+            os.environ.pop('SITK_SHOW_COMMAND', None)
+            mock_sys.platform = 'linux'
+            mock_shutil.which = lambda x: '/usr/bin/itksnap' if x == 'itksnap' else None
+            result = tio.utils.guess_external_viewer()
+            assert result == Path('/usr/bin/itksnap')
+
+    def test_guess_external_viewer_none(self):
+        """guess_external_viewer returns None when no viewer found."""
+        with (
+            patch('torchio.utils.sys') as mock_sys,
+            patch('torchio.utils.shutil') as mock_shutil,
+            patch.dict(os.environ, {}, clear=False),
+        ):
+            os.environ.pop('SITK_SHOW_COMMAND', None)
+            mock_sys.platform = 'unknown_platform'
+            mock_shutil.which = lambda x: None
+            result = tio.utils.guess_external_viewer()
+            assert result is None
+
+    def test_guess_external_viewer_linux_slicer(self):
+        """guess_external_viewer finds Slicer on Linux when itksnap absent."""
+        with (
+            patch('torchio.utils.sys') as mock_sys,
+            patch('torchio.utils.shutil') as mock_shutil,
+            patch.dict(os.environ, {}, clear=False),
+        ):
+            os.environ.pop('SITK_SHOW_COMMAND', None)
+            mock_sys.platform = 'linux'
+            mock_shutil.which = lambda x: '/usr/bin/Slicer' if x == 'Slicer' else None
+            result = tio.utils.guess_external_viewer()
+            assert result == Path('/usr/bin/Slicer')
+
+    def test_apply_transform_verbose_history(self):
+        """apply_transform_to_file with verbose prints history."""
+        transform = tio.RandomFlip()
+        tio.utils.apply_transform_to_file(
+            self.get_image_path('input_v'),
+            transform,
+            self.get_image_path('output_v'),
+            verbose=True,
+        )

tests/test_utils.py

@@ -368,3 +368,49 @@ def __call__(self, data):
         assert not isinstance(transformed['mean'], tio.Image)
         assert isinstance(transformed['indices'], torch.Tensor)
         assert not isinstance(transformed['indices'], tio.Image)
+
+    def test_repr(self):
+        """__repr__ includes the adapter name and wrapped transform."""
+        transform = tio.MonaiAdapter(NormalizeIntensityd(keys=['t1']))
+        result = repr(transform)
+        assert 'MonaiAdapter' in result
+        assert 'NormalizeIntensityd' in result
+
+    def test_to_hydra_config_raises(self):
+        """to_hydra_config raises NotImplementedError."""
+        transform = tio.MonaiAdapter(NormalizeIntensityd(keys=['t1']))
+        with pytest.raises(NotImplementedError, match='Hydra'):
+            transform.to_hydra_config()
+
+    def test_array_transform_non_tensor_result_raises(self):
+        """Array transform returning non-tensor raises TypeError."""
+
+        class BadArrayTransform:
+            def __call__(self, x):
+                return 'not a tensor'
+
+        subject = tio.Subject(
+            t1=tio.ScalarImage(tensor=torch.randn(1, 10, 10, 10)),
+        )
+        transform = tio.MonaiAdapter(BadArrayTransform())
+        with pytest.raises(TypeError, match='Expected a torch.Tensor'):
+            transform(subject)
+
+    def test_dict_transform_non_tensor_for_image_raises(self):
+        """Dict transform returning non-tensor for image key raises TypeError."""
+
+        class BadDictTransform(MapTransform):
+            def __init__(self):
+                super().__init__(keys=['t1'])
+
+            def __call__(self, data):
+                data = dict(data)
+                data['t1'] = 'not a tensor'
+                return data
+
+        subject = tio.Subject(
+            t1=tio.ScalarImage(tensor=torch.randn(1, 10, 10, 10)),
+        )
+        transform = tio.MonaiAdapter(BadDictTransform())
+        with pytest.raises(TypeError, match='Expected a torch.Tensor'):
+            transform(subject)